These Edy Hourany

THÈSE DE DOCTORAT
DE L’ÉTABLISSEMENT UNIVERSITÉ BOURGOGNE FRANCHE-COMTÉ
PRÉPARÉE À L’UNIVERSITÉ DE FRANCHE-COMTÉ
École doctorale n°37
Sciences Pour l’Ingénieur et Microtechniques
Doctorat d’Informatique
par
Edy Hourany
Leader election and fault detection for secured self-reconfigurable modular robots
Election de leader et détection de fautes pour robots modulaires sécurisés et auto-reconfigurables
Thèse présentée et soutenue à Montbéliard, le 13 decembre 2022

Composition du Jury :
El Baz Didier Chargé de Recherche au CNRS, LAAS/CNRS Rapporteur
Kheddouci Hamamache Professeur à l’Université Claude Bernard Lyon 1 Rapporteur
Abouaissa Abdelhafid Professeur à l’Université de Haute-Alsace Examinateur
Makhoul Abdallah Professeur à l’Université de Franche-Comté Examinateur
Bourgeois Julien Professeur à l’Université de Franche-Comté Directeur de thèse
Habib Bachir MCF à l’Université Saint Esprit de Kaslik Codirecteur de thèse
N◦ X X X
Acknowledgement
I would like to thank all thesis committee members for having accepted to take the time to
review my dissertation and provide valuable feedback.
Throughout the writing of this dissertation I have received a great deal of support and assis-
tance. I would first like to thank my director, Professor Julien Bourgeois, whose expertise was
invaluable in formulating the research questions and methodology. I would like to also thank
Dr. Bachir Habib and my supervisors, Professor Abdallah Makhoul and Dr Benoit Piranda.
Your insightful feedback pushed me to sharpen my thinking and brought my work to a higher
level. I would like to acknowledge Dr Laurence Ajaka for her valuable guidance throughout my
studies.
In addition, I would like to thank my family for their wise counsel and sympathetic ear. You are
always there for me. Finally, I could not have completed this dissertation without the support
of my wife, Nathalie who provided stimulating discussions as well as happy distractions to rest
my mind outside of my research.
Thank You.
iii
iv
Admit it:
Ordinary matter
is kind of boring.
UNKNOWN
Abstract
Recent advancements in science foreshadow that in the next few decades it might be possible
to assemble simple information processing units at almost no cost. Myriads of these small-scale
units could be combined to powerful systems capable of solving intricate tasks, this is called
programmable matter. This vision of building cheap microscopic processing units is supported
by the progress made in manufacturing microelectro mechanical components, such that one can
anticipate integrating logic circuits, microsensors, microactuators, and communication devices
on the same chip.
This thesis presents four algorithms that propose a solution to four of the main issues in
programmable matter: Leader election, reconfiguration, error detection, and security. The
leader election algorithm deterministically elects a leader in a modular robotic system regardless
of the modules’ type and configuration. The reconfiguration problem occurs when too many
particles are moving at the same time. This might lead to collisions among modules. To solve
this problem, a reconfiguration algorithm is created based on virtual forces. This algorithm
tackles the self-reconfiguration problem by presenting a deterministic planning algorithm that
can decide which positions can be filled over multiple iterations using virtual forces. To detect
errors in programmable matter systems, an error detection algorithm called DETECTOR is
proposed. It is a hierarchically distributed fault detection algorithm, it allows the detection of
disconnections in a hierarchical manner. The leader of the system will construct the spanning
tree, assign coordinates to each module and compare them to detect the disconnections. And
finally, to ensure security in programmable matter, a security protocol is developed to solve
the issue. This protocol is based on lightweight cryptography and uses the same encryption
protocol as a hashing function while keeping the distributed architecture in mind. The analysis
and simulation results show the efficiency of the proposed method.
v
Résumé
Les récents progrès de la science laissent présager que, dans les prochaines décennies, il pourrait
être possible d’assembler des unités simples de traitement de l’information pour un coût presque
nul. Des myriades de ces petites unités pourraient être combinées pour former des systèmes
puissants capables de résoudre des tâches complexes. Cette vision de la construction d’unités de
traitement microscopiques bon marché est soutenue par les progrès réalisés dans la fabrication
de composants microélectro mécaniques, de sorte que l’on peut envisager d’intégrer des circuits
logiques, des microcapteurs, des microactionneurs et des dispositifs de communication sur la
même puce.
Cette thèse présente quatre algorithmes qui proposent des solutions à quatre des principaux
problèmes de la matière programmable : l’élection du leader, la reconfiguration, la détection
des erreurs et la sécurité. L’algorithme d’élection du leader élit de manière déterministe un
leader dans un système robotique modulaire, indépendamment du type et de la configuration
des modules. Le problème de reconfiguration se produit lorsque trop de particules se déplacent
en même temps. Cela peut entraı̂ner des collisions entre les modules. Pour résoudre ce
problème, un algorithme de reconfiguration basé sur les forces virtuelles est créé. Cet
algorithme s’attaque au problème de l’auto-reconfiguration en présentant un algorithme de
planification déterministe qui peut décider quelles positions peuvent être remplies sur plusieurs
itérations en utilisant des forces virtuelles. Pour détecter les erreurs dans les systèmes de
matière programmable, un algorithme de détection d’erreurs appelé DETECTOR est proposé.
C’est un algorithme de détection de fautes distribué hiérarchiquement, il permet de détecter
les déconnexions de manière hiérarchique. Le leader du système va construire l’arbre de
recouvrement, attribuer des coordonnées à chaque module et les comparer pour détecter les
déconnexions. Et enfin, pour assurer la sécurité dans la matière programmable, un protocole
de sécurité est développé pour résoudre le problème. Ce protocole est basé sur la cryptographie
légère et utilise le même protocole de cryptage comme fonction de hachage tout en gardant à
l’esprit l’architecture distribuée. Les résultats d’analyse et de simulation montrent l’efficacité
de la méthode proposée.
vii
Acronyms
• AIM: Assembly Incidence Matrix. 31
• CCW: Counter Clock Wise. 73–76, 82
• CW: Clock Wise. 73–76, 82
• DOF: Degree Of Freedom. 15, 21, 23, 30
• FCC: Face Centered Cubic. 72
• GA: Genetic Algorithm. 16, 35, 37
• MRR: Modular Reconfigurable Systems. 89
• MRS: Modular Robotic Systems. 2, 4–7, 10, 15, 17, 22, 46, 47, 66, 88, 89, 102
• MRTP: Modular Robot Time Protocol. 7, 8
• PMS: Programmable Matter Systems. 2–4, 12, 102
• SMORES: Self-assembling Modular Robot for Extreme Shapeshifting. 27
• VF: Virtual Forces. 76, 82, 162
• VFA: Virtual Force Algorithm. 70, 71, 75, 134
• WSN: Wireless sensor network. 134
ix
Contents
1 Introduction 1
1.1 Research Context . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Motivation and inspiration . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.1 Functional advantage . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.2 Economic advantage . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3 Background Description and Definitions . . . . . . . . . . . . . . . . . . . . . 6
1.3.1 Blinky Blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.2 Definitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4 Contribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.5 Outline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2 Modular Robots Generalities 13
2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2 History and Architecture of Modular Robots . . . . . . . . . . . . . . . . . . . 15
2.2.1 Classification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.2.2 Connections and Network . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2.3 Actuation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.2.4 Mobility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.2.5 Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2.6 Multiple types of robots . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.3 Modular Robots Characteristic . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.3.1 Symmetry . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.3.2 Scale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.3.3 Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
2.3.4 Homogeneity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
xi
xii CONTENTS
2.4 Application area . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.4.1 Space exploration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.4.2 Telepario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.4.3 Bucket of stuff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.4.4 Medical Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.5 Challenges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.5.1 Self-Assembly . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.5.2 Self-reconfiguration . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.5.3 Self-Repair . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
2.5.4 Self-Reproduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
2.5.5 Self-sufficiency . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
2.5.6 ID Assignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
2.5.7 Leader Election . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
2.5.8 Security . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
2.5.9 Clustering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
2.6 Ethics in Modular Robots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
2.7 Simulation Environment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3 Leader Election 45
3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.1.1 Existing Leader election algorithms . . . . . . . . . . . . . . . . . . . . 46
3.2 Proposed algorithm and contribution . . . . . . . . . . . . . . . . . . . . . . . 48
3.2.1 Computing the weight parameter . . . . . . . . . . . . . . . . . . . . . 49
3.2.2 Recruitment phase . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.2.3 Tree value computation . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.2.4 Competition with other trees . . . . . . . . . . . . . . . . . . . . . . . 53
3.2.5 Dismantling trees and more recruitment . . . . . . . . . . . . . . . . . 55
3.2.6 Leader election phase . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.3 Termination with no Leader . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
3.4 Complexity analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

CONTENTS xiii
3.4.1 Theoretical analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
3.4.2 Empirical analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
3.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4 Reconfiguration using virtual forces 69
4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
4.2 Literature Review . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
4.3 Assumptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
4.4 Proposed Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.4.1 Distributed Virtual Force Algorithm (VFA) . . . . . . . . . . . . . . . . 75
4.5 Simulation Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
4.6 Conclusions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
5 Fault detection 87
5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
5.2 Background . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
5.3 Detector: disconnection detection . . . . . . . . . . . . . . . . . . . . . . . . 89
5.3.1 Definitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
5.3.2 The Proposed Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . 92
5.4 Simulation Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
5.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
6 PROLISEAN 101
6.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
6.2 Background Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
6.2.1 Lightweight cryptography . . . . . . . . . . . . . . . . . . . . . . . . . 103
6.2.2 Hardware consideration . . . . . . . . . . . . . . . . . . . . . . . . . . 105
6.3 PROLISEAN: our proposed protocol . . . . . . . . . . . . . . . . . . . . . . . 106
6.3.1 Risk study through EBIOS method . . . . . . . . . . . . . . . . . . . . 106
6.3.2 Proposed algorithm: PROLISEAN . . . . . . . . . . . . . . . . . . . . 110
6.3.3 Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

xiv CONTENTS
6.4 Algorithm analysis and proposed solutions . . . . . . . . . . . . . . . . . . . . 123
6.4.1 The block cipher . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
6.4.2 The Hash function . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
6.4.3 Proposed Hashing function . . . . . . . . . . . . . . . . . . . . . . . . 128
6.5 Simulation and differential cryptanalysis . . . . . . . . . . . . . . . . . . . . . 129
6.5.1 Simulations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
6.5.2 Differential cryptanalysis . . . . . . . . . . . . . . . . . . . . . . . . . 131
6.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
7 Conclusion 133
1
Introduction
Contents
1.1 Research Context . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Motivation and inspiration . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.1 Functional advantage . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.2 Economic advantage . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3 Background Description and Definitions . . . . . . . . . . . . . . . . 6
1.3.1 Blinky Blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.2 Definitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4 Contribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.5 Outline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1
2 Introduction
1.1/ Research Context
The field of Programmable Matter Systems (PMS) and Modular Robotic Systems (MRS) has
been evolving since the 90’s and the work of Toshio Fukuda on CEBOT Fukuda et al. (1990).
The pioneering work of early researchers in this field laid the foundation for the development
of PMS and MRS. Researchers like Kyle Gilpin, Seth Copen Goldstein, and Julien Bourgeois
made significant contributions to the study of the concept of programmable matter.
Kyle Gilpin was a researcher in the field of modular robotics who made substantial contribu-
tions to the understanding of the development and implementation of these systems Gilpin
et al. (2010b). He emphasized the significance of both hardware design and algorithms in
achieving success in modular robotics, arguing that innovations in both areas were essential
for these systems to match shape and function, as well as perform tasks such as computation,
communication, sensing, and power transfer within small form factors of centimeters or less
Gilpin et al. (2008). Gilpin’s work, which provided a retrospective on modular robots and their
connections to programmable matter, was particularly unique as it offered insights into the
capabilities of modular robots and emphasized the importance of both hardware and software
innovations in making modular robots successful Gilpin et al. (2010a). His contribution has
shaped the understanding of the development and implementation of modular robots and has
been a valuable addition to the field.
Seth Copen Goldstein is a pioneer in the field of robotics and has made significant contributions
to the development of the Claytronics project Goldstein et al. (2004). This project aims to
tackle the idea of a matter composed of millimeter-scale robots, and proposes a concept of
modular robots that can work together to achieve a global effect not possible by any single
unit. The project was first proposed by Goldstein and Mowry in 2004, and has since become
a landmark in the field of robotics.
One of Goldstein’s early contributions to the field is his paper titled ”Stress-driven MEMS
assembly + electrostatic forces = 1mm diameter robot” Karagozler et al. (2009). This paper
describes the manufacturing methods and mechanisms for producing a 1 millimeter diame-
ter module, which can be mass produced. This work is an important step towards realizing
Claytronics, a modular robotic system that is designed to scale up to millions of units. Addition-
ally, the paper highlights the importance of decreasing the size of modules in self-reconfiguring
systems while increasing their number, which leads to increased flexibility as a whole.
Goldstein’s work on declarative programming for modular robots, Ashley-Rollman et al.

(2007a), is another important contribution. In his paper ”Declarative programming for modular
robots” he investigates two programming models for modular robot ensembles and compares
their performance, optimization, and other features in the context of a metamodule-based
shape planning algorithm. The research aims to evaluate the advantages of using declarative
programming, as opposed to imperative approaches, for complex tasks. The paper uses Meld
1.1. RESEARCH CONTEXT 3
and LDP as examples to demonstrate the implementation of the algorithm using these lan-
guages, which results in a substantial reduction in code size compared to an earlier imperative
implementation. Specifically, the new implementation achieved twenty times reduction in code
size.
In ”Generalizing metamodules to simplify planning in modular robotic systems”, Goldstein

extends his work on metamodules and presents a theory of metamodules and an associated
distributed asynchronous planner that is applicable to various modular robotic systems Dewey
et al. (2008). This paper describes how metamodules, which are groups of modules that
act as one unit, allow for reduced motion constraints and complexity in planning tasks. The
proposed holonomic metamodule has two important properties: it can be used with efficient
planners, and it can be instantiated by different underlying modular robots, such as robot
arms or expanding cubes. The paper includes a series of transformations that demonstrate the
practicality of this system’s complete planner, as well as how shape transformation tasks can
be separated into separate planning and resource allocation processes.
In ”Meld: A declarative approach to programming ensembles”, Goldstein presents Meld, a

programming language for modular robots Ashley-Rollman et al. (2007b). The main feature
of Meld is that it uses logic programming, which allows code for an ensemble of robots to be
written from a global perspective instead of having multiple independent robot views. This
simplifies the process of writing programs with large ensembles and results in a reduction in
the complexity and size of codes compared to C++ languages used earlier. An initial imple-
mentation has been completed using the Claytronics simulator, which shows that programs
written in this new language are more than 20 times shorter while running nearly as efficiently
as before.
Finally, in ”Scalable shape sculpting via hole motion: Motion planning in lattice-constrained
modular robots”, Goldstein presents a novel algorithm for ensembles of 2-dimensional lattice-
arrayed modular robots to form shapes De Rosa et al. (2006). The algorithm is massively
parallel and fully distributed, meaning that it does not require global communication or broad-
cast floods after the target shape has been set. Additionally, the algorithm requires time
proportional only to the complexity of the desired geometry, allowing for quick construction of
shapes. Simulation results show 97.3% compliance with approximately 60, 000 modules being
used as part of an ensemble, suggesting that scaling up could allow millions more modules
without compromising accuracy or speediness when forming shapes from them.
Julien Bourgeois significant contributions on PMS like proposing the first toolkit for represent-
ing a shape for self-reconfiguration Tucci et al. (2017), or greatly speeding up reconfiguration
time. The best reconfiguration methods gave time in the range of ten hours Pierre (2019).
Bourgeois also developed a distributed algorithm for part differentiation in smart surfaces which
can be used to differentiate parts with high level of parallelism. It also presents an implemen-
tation model and the Java Smart Surface Simulator (SSS) that runs on multi-core machines,
4 Introduction
allowing researchers to obtain computational results quickly and accurately. The proposed
algorithms are useful for real time applications as they provide efficient ways of differentiating
parts from each other without any manual intervention or external input devices like cameras
etc El Baz et al. (2012). They have proposed three concepts Pierre (2019) to improve this
time, which allowed them to obtain a reconfiguration of the order of a second for more than
1000 robot moved. This acceleration is a real breakthrough and allows to change completely
the field of possibilities for the applications of programmable matter. The three concepts intro-
duced are the following: an object is first built with a regular porous internal structure Thalamy
et al. (2020b) composing what is called a scaffolding, around this structure comes to position
an envelope of the thickness of a robot Thalamy et al. (2020a). The porous structure allows
the robots to pass inside the object, which considerably reduces the construction time. The
third device is called a sandbox. This is a source of modules on which the construction rests,
which serves as both a reserve and a foundation, responsible for directing a flow of modules
to different points of the object.
The cooperation between Goldstein and Bourgeois has proposed interesting work on the char-
acterization of networks of lattice-based modular robots Naz et al. (2018c), a time synchroniza-
tion protocol Naz et al. (2018b) a leader election for finding the center in a modular robot Naz
et al. (2018a, 2015) and self-reconfiguration without a map. They also defined the concept of
distributed intelligent micro-electro-mechanical systems (DiMEMS) Bourgeois et al. (2012). In
Bourgeois et al. (2013), the authors added embedded intelligence to MEMS systems, so that
they will be able to collaborate efficiently. This will require embedding MEMS sensors/actu-
ators, electronics, communication capabilities, control of actuators and programs in the same
unit. They suggested the use of the phrase ”distributed intelligent MEMS (diMEMS)” when
referring to such systems.
The early works of these researchers helped establish the concept of modular robotics and
programmable matter. They focused on the design of modular robotic systems and the devel-
opment of algorithms to control the behavior of these systems. This work was crucial in laying
the foundation for the development of PMS and MRS as we know them today.
The advancement of technology has enabled the manipulation of matter in new and innovative
ways, leading to the creation of PMS. This system is composed of several components, each
being a miniature robot with varying levels of automation, that can be connected to form a
larger robot capable of performing a wide range of tasks. The versatility and customization of
PMS and MRS make them a unique and valuable addition to the field of robotics.
One of the key advantages of PMS and MRS is their versatility and customization. The
modular design of these systems allows for the customization of each component, making it
possible to configure the system for different tasks. The system can also be easily reconfigured
if the task requirements change. This flexibility makes PMS and MRS a valuable tool for a
variety of applications, including capture, rescue, and exploration.
1.2. MOTIVATION AND INSPIRATION 5
Blinky Blocks are a type of programmable matter system that allow for dynamic and interactive
behavior through color changes, sound emission, audio detection, and vibration. These modular
robots consist of individual blocks that can communicate and coordinate with each other to
form a larger system.
Blinky Blocks were first developed at the Carnegie Mellon University (CMU) and have since
become a popular platform for researchers in the field of programmable matter systems. The
modularity and reconfigurability of Blinky Blocks make them ideal for exploring various scientific
problems, such as self-assembly, cooperative behavior, and distributed control.
One of the unique aspects of Blinky Blocks is their ability to change color, emit noise, detect
audio, and vibrate. These capabilities enable them to interact with their environment and with
each other in ways that other systems cannot. For example, Blinky Blocks can be used to
create interactive displays or musical instruments.
Blinky Blocks also have potential applications in a variety of fields, including education, enter-
tainment, and robotics. For example, they can be used in educational settings to help students
learn about programming, engineering, and basic scientific principles. In entertainment, Blinky
Blocks can be used to create interactive exhibits or performances.
Despite their potential, Blinky Blocks still face a number of challenges. For example, ensuring
reliable communication between the blocks and improving their energy efficiency are two areas
of ongoing research. Additionally, researchers are exploring ways to make the blocks more
versatile, such as by incorporating additional sensors or actuators.
Overall, Blinky Blocks are a valuable platform for exploring the field of programmable matter
systems. Through their ability to change color, emit noise, detect audio, and vibrate, they pro-
vide unique opportunities for researchers to study dynamic and interactive behavior in modular
systems. As research in this field continues to progress, it will be interesting to see what new
applications and advancements will emerge for Blinky Blocks and other programmable matter
systems.
1.2/ Motivation and inspiration
Designing MRS is motivated by two main factors: functional advantage and economic advan-
tage.
1.2.1/ Functional advantage
MRS have the potential to be more resilient and more adaptable than traditional robotic
systems. The reconfiguration ability enables a robot or a collection of robots to deconstruct
and reassemble machines to create new morphologies that are better suited to new tasks, such
6 Introduction
as transitioning from a legged robot to a snake robot (snakebot) and subsequently to a rolling
robot. Because robot parts are interchangeable (both inside and between robots), machines
may replace broken parts on their own, resulting in self-repair.
1.2.2/ Economic advantage
By constructing a variety of sophisticated machines from a single (or relatively few) types of
mass-produced modules, self-configuring robotic systems have the potential to reduce total
robot costs.
Both of these benefits have yet to be fully realized. A modular robot’s performance is likely to
be lower than that of a single specialized robot designed for a specific activity. However, the
benefit of modular robotics becomes obvious only when many jobs that would otherwise need
a variety of robots are considered.
The added degrees of freedom make modular robots more versatile in their potential capa-
bilities, but also incur a performance trade-off and increased mechanical and computational
complexities.
Long-term space missions, for example, require a long-term self-sustaining robotic ecosystem
that can manage unanticipated events and may require self-repair, which has sparked interest
in self-reconfiguring robotic structures. Biological systems, which self-assemble from a limited
set of lower-level building pieces, are a second source of inspiration. The capacity of biological
systems to physically adapt, develop, heal, and even self-replicate is based on this design, which
is desirable in many constructed systems.
1.3/ Background Description and Definitions
The term of programmable matter appeared a quarter century ago and was defined as a
matter that is able to modify its physical properties like shape, color or density autonomously
or controlled by a user. The most common solution known is to use a huge number of small
robots comparable to the cells that compose our body. This comparison gave its name to this
solution: Amoebots Derakhshandeh et al. (2016); Thalamy et al. (2019b); Luna et al. (2017).
Modular robotics are robots designed with parts that can be reconfigured to accept different
functions ?. They are autonomous systems with variable morphology. These systems are
composed of independent connected elements called modules or particles, whose connections
to one another form the overall shape of the system Ahmadzadeh et al. (2016).
MRS may construct their own structure, make alterations, or change the geometry of the
structure. While traditional robots are limited to a single application or goal, modular robots
have the potential to perform a wide range of missions Ahmadzadeh et al. (2015).
1.3. BACKGROUND DESCRIPTION AND DEFINITIONS 7
A MRS is a system that is presented as an undirected graph where the vertices are the modules
(or sometimes called particles) and the edges are the communication links between neighbour-
ing particles.
When working with modular robots, researchers face different challenges such as the connec-
tions between the particles, the data transfer among the modules, the communication inside
the structure or the ability to localize its own position in the space. Today, manufacturing
amoebots is impossible but the technologies of micro-fabrication and cellar engineering have
made such advances that the probability of discovering how to build it rises every day. That is
why research centers over the world are looking for theoretical models to face the maximum
of issues concerning programmable matter Derakhshandeh (2017).
This work is based on the general definition of amoebot model provided in the second part
of the document Derakhshandeh (2017) that state programmable matter as a uniform set of
simple computational units. In the general amoebot model, all the particles are connected to
at least another one and needs to connect with several particles to be able to move inside the
structure. None of the particles is free to flow inside the structure.
In this research, all the algorithms were developed to work on Blinky Blocks with the exception
of the reconfiguration algorithm using virtual forces in chapter 4. As a matter of fact, the
reconfiguration algorithm was developed and tested on VisiblSim using 2D Nodes because,
unlike Blinky Blocks, they have the ability to move.
All the particles are considered to be uniform. They are anonymous and indistinguishable
they have the same clockwise orientation and execute the same program. The communication
among the modules happens through exchanging messages. Each particle can communicate
with its adjacent neighbors only. A particle’s neighbor is defined as being the module that is
directly connected to that particle through an interface. Modules are only aware of their status
and their neighbors’ status.
1.3.1/ Blinky Blocks
Modular robots are a relatively new field in robotics and offer many unique advantages com-
pared to traditional robots. One such example of a modular robot is Blinky Blocks. Blinky
Blocks are a simple model of a non-self-reconfigurable modular robot that is designed to be
inexpensive to manufacture in large quantities. Unlike other modular robots, the Blinky Blocks
can be detached from one location and attached to another while still maintaining the overall
system consistency.
Blinky blocks use a new method for synchronizing the time across their network Naz et al.
(2016b). The Modular Robot Time Protocol (MRTP), combines several mechanisms to achieve
its performance. The first mechanism is a central time master election, where one node is
elected as the main source of synchronization for all other nodes in the network. The second
8 Introduction
mechanism is low-level time stamping, which records timestamps at each hop from the master
node. Finally, clock skew compensation using linear regression helps adjust any discrepancies
between the timestamps.
Experiments conducted on the hardware demonstrate the effectiveness of MRTP. Results show
that MRTP can manage real systems composed of up to 27,775 Blinky Blocks with few
resources at runtime and keep them synchronized within milliseconds precision depending on
various factors like hop distance from the master node. This is particularly important given
the poor accuracy and resolution of the clocks used by these blocks.
The practical implications are significant for managing large scale robotic networks. The
ability to synchronize time across a network of modular robots within milliseconds precision
is an important factor for ensuring their coordination and effective functioning. The results
show that MRTP is an effective solution for achieving this goal. Additionally, the use of few
resources at runtime means that the system can be managed efficiently and effectively, which
is important for large scale deployment.
The Blinky Blocks are cube-shaped and approximately 40mm in size, with a 10mm extrusion
at the top and a corresponding cavity at the bottom. They weigh approximately 50 grams
and are equipped with powerful processing, communication, and storage capabilities. Each
block contains an 8-bit RISC processor operating at 32 MHz, 80 KB SRAM, and 1.25 MB
FLASH, as well as communication channels that operate at speeds of up to 2 Mbps Kirby
et al. (2011). The white opaque shell of the blocks is designed to diffuse the RGB LED lights
and facilitate reliable connections between blocks through the alignment of magnets within
the interior. Rare earth magnets are arrayed to repel incorrect assembly and provide a strong
cohesive force that enables stacking over 15 blocks vertically and cantilevering at least 4 blocks
horizontally, allowing for the construction of large and complex structures.
The Meld programming language, a logic-based distributed language, has been adapted to
run on the Blinky Blocks. The language abstracts away the distributed nature of the system,
allowing programmers to program the blocks as if writing a single program that has access
to the features of all blocks. The Meld compiler and runtime take care of distributing the
execution and data storage, handling messages, faults, and changes in topology, freeing the
programmer to focus on the logic of the system. The build system enables programming,
simulation, and recompilation for various ensembles of blocks, making it possible to write
programs for ensembles of 10 or 100 blocks.
The primary mode of user input to the Blinky Blocks is reconfigurability, with color change
being the primary mode of feedback through the RGB LED lights. The blocks can also detect
changes in orientation, sudden impulses, play sounds through the onboard speaker, and capture
sound with the onboard microphone. These secondary capabilities allow the Blinky Blocks to
interact with end users in a more tangible and interactive manner. Additionally, the Meld
programming language is designed to express topological conditions and is a perfect match for
1.3. BACKGROUND DESCRIPTION AND DEFINITIONS 9
the Blinky Blocks, making them a valuable platform for exploring the utility of this language
in a live system Kirby et al. (2011).
Blinky Blocks offer a unique and valuable platform for exploring various aspects of modular
robots, including modularity, scalability, and reconfigurability. These capabilities are essential
for the development of future modular robots that can be adapted to changing environments
and applications. By exploring the use of Blinky Blocks, researchers and developers can gain
valuable insights into the potential of modular robots and the challenges they face.
In conclusion, Blinky Blocks are an excellent example of the potential of modular robots and
offer a valuable platform for exploring the capabilities and limitations of modular robots. The
Meld programming language and the build system offer a simple and intuitive way to program
and simulate the Blinky Blocks, making them an ideal platform for educational and research
purposes. The reconfigurability, scalability, and modularity of Blinky Blocks make them a
valuable asset in the development of future modular robots and the advancement of the field
of robotics as a whole.
In this thesis, and throughout out my entire research, I will focus my work on Blinky Blocks
that are introduced later in section 2.2.6.11.
1.3.2/ Definitions
In this paragraph we will be going through all the definitions of the terms used in this thesis.
Definition 1: Particle/module
A particle, also referred to as a module, is defined by being a conceptual model for a

computational entity in an infinite regular grid. A module can take different forms.
In one system, only one type of particles is used. Multiple types of modules exist
leading to different organisations, such as a regular like square lattice (Smart Blocks),
hexagonal, cubic lattice (Blinky Blocks), FCC lattice (3D Catom), free positions
(Kilobots) Ünsal et al. (2001), and droplet Devi et al. (2013). It is important to note
that modules have a constant memory size.
Definition 2: Weight
The weight of a robot is defined as an intrinsic value calculated from the list of its
connection to neighbors. This concept is explained in details in subsection 3.2.1
10 Introduction
Definition 3: Symmetrical system
Axial symmetry is usually defined as the geometrical quality of being made up of

exactly similar parts facing each other around an axis. In addition, in the proposed
approach, the weight of the modules was taken into consideration as an added con-
dition to accomplish, a so called, symmetrical system.
Definition 4: Anonymity
Considering anonymity of the robots is interesting as it could simplify the hardware

and software systems.
Definition 5: Identical modules
All the modules have the same design, the same hardware and the same algorithms.
Definition 6: Fixed memory
The overall memory of 128KB for the application (including the firmware) and 32 KB
for the data, prevents the usage of heavy algorithms thus creating new algorithms to
solve traditional problems.
Definition 7: Fixed connection of a module with its neighbors
A Blinky Block module always have at least one neighbor in the structure and max-
imum of 4 neighbors in 2D and 6 in 3D.
Definition 8: Joint internal clock
The moment we turn the MRS on (in this case the Blinky Blocks), all the modules
begin with having the same internal clock. However in this case, since the modules
have the same internal clock at the time of system start-up, then they will generate
the same random numbers. Since all the Blinky Blocks V2 that are used are identical,
the change of the seed will not solve the problem; it will continue to generate the
same random numbers.
It is important to note that maintaining a synchronized clock is a difficult task to
achieve. Given the fact that modular robots are made of cheap material, clocks will
not be synchronized the whole time. In this manuscript, nevertheless, we consider
that all modules are logically synchronized due to the fact that it is very difficult to
determine the exact moment the internal clocks deviate. In addition, it is important
to note that the election of the leader, mentioned in chapter 3, happens the moment
the MRS starts, in other words, when the Blinky Blocks’ internal clocks are not yet
deviated. Even though clocks all start at the same time and are synchronized, the
programming model remains an asynchronous one.
1.4. CONTRIBUTION 11
Definition 9: Peer to peer communication by contact
A Blinky Block can only communicate with its neighbors, it is not able to contact
another modules except the ones that are directly and physically connected to its
ports.
Definition 10: Leader
A leader election algorithm is a method used by distributed systems to select one node
from among a group of nodes to serve as the leader. The leader is a special module
that plays a unique and central part in the execution of distributed algorithms. It is
responsible for coordinating the activities of the other nodes, such as communication,
managing resources, and making decisions. The algorithm ensures that only one
node is elected as the leader, even if multiple nodes initiate the election process
simultaneously.
Definition 11: Connected Modules
Connected modules are latched neighbors that are able to communicate throw their
common interface.
1.4/ Contribution
The basic strategy is to construct smart materials that can be modeled and manipulated. An-
other technique to program matter is to embed it with code that allows it to respond to external
stimuli (such as heat or water). Programmable substances may be used to create prototypes,
distort robots, and even houses and structures. With the help of external commands, the ”Pro-
grammable Matter” project hopes to demonstrate a new functional form of matter based on
mm-scale particles. Nevertheless, it is difficult to integrate and coordinate sensors, actuators,
computing, and communication tightly into robotic materials, while preserving reconfiguration
and particles’ motion.
We will be exploring the feasibility of overcoming basic difficulties related to programmable

matter by imagining systems composed of mm-scale robots. These robots are aligned on a
regular structure called a lattice, which construct an organized arrangement of robots. Chain
modular robots are restricted in their physical arrangement and therefore cannot represent any
shape, like lattice modular robots do. Lattice structures vary in packing density, number of
dimensions, and number of adjacent positions depending on the shape of their cells Naz et al.
(2018b); Piranda et al. (2018). Different modular robots have different lattice geometries.
A 3D lattice-based metamorphic system may be self-reconfigured using a modular robotic
architecture.
12 Introduction
We will use lattice-based modular robotics to represent such self-organizing particle systems.
Particles that can bond with nearby particles to build connected structures are PMS in this
paradigm. We will see that in this work, we have developed a lot of algorithms that are based
on graph structure where we have waves to assure a synchronous functioning of the particles.
It is possible to explore several fundamental issues in such systems. In this dissertation, we will
examine leader election, self-configuration, fault detection, and security.
1.5/ Outline
This thesis proposes four algorithms that address four major challenges in programmable mat-
ter. Leader election, reconfiguration, security, and error detection. To address the issue of
leader election, this thesis proposes a new election algorithm. The suggested approach creates
a spanning forest by determining the weights of each module. Until one tree survives, each
spanning tree competes with its neighbors. The system’s leader is the root of the remaining
spanning tree. In a programmable matter system, the reconfiguration issue arises when too
many changes occur at once. A reconfiguration mechanism based on virtual forces is developed
to address this. With virtual forces, this method solves the self-reconfiguration problem. For
example, the suggested algorithm reduces the number of moves and avoids blocking locations.
In neighbor-to-neighbor communication, each module embeds the same algorithm. The pro-
posed technique is tested using simulation results. Third, an approach named DETECTOR
is suggested to identify defects in Programmable Matter Systems (PMS). In a hierarchical
approach, it detects disconnections. Assigning coordinates to each module and comparing
them to find disconnections. This continues until the leader is reached. Finally, a new se-
curity protocol is created to address programmable security. A hashing function is used to
encrypt data using lightweight cryptography. It takes years for a supercomputer to decrypt the
communication, according to analyses and simulations.
2
Modular Robots Generalities
Contents
2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2 History and Architecture of Modular Robots . . . . . . . . . . . . . 15
2.2.1 Classification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.2.2 Connections and Network . . . . . . . . . . . . . . . . . . . . . . . 18
2.2.3 Actuation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.2.4 Mobility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.2.5 Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2.6 Multiple types of robots . . . . . . . . . . . . . . . . . . . . . . . . 22
2.3 Modular Robots Characteristic . . . . . . . . . . . . . . . . . . . . . 30
2.3.1 Symmetry . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.3.2 Scale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.3.3 Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
2.3.4 Homogeneity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
2.4 Application area . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.4.1 Space exploration . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.4.2 Telepario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.4.3 Bucket of stuff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.4.4 Medical Application . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.5 Challenges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.5.1 Self-Assembly . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.5.2 Self-reconfiguration . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.5.3 Self-Repair . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
2.5.4 Self-Reproduction . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
2.5.5 Self-sufficiency . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
2.5.6 ID Assignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
2.5.7 Leader Election . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
2.5.8 Security . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
13
14 Modular Robots Generalities
2.5.9 Clustering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
2.6 Ethics in Modular Robots . . . . . . . . . . . . . . . . . . . . . . . . 41
2.7 Simulation Environment . . . . . . . . . . . . . . . . . . . . . . . . . 43
2.1. INTRODUCTION 15
2.1/ Introduction
rogrammable Matter is a term first coined in 1991 by Toffoli and Margolus Toffoli et al.
P (1991) to refer to a collection of fine-grained computer elements located in space. A
programmable material is a material whose properties can be programmed to produce specific
shapes or stiffness upon command. Thus, programmable matter is related to the concept
of a material that inherently has the ability to perform information processing. Robots with
modular designs are composed of multiple individual units, which are referred to as modules.
Each module is equipped with multiple actuators and sensors, as well as computational and
communication capabilities. The modules within a modular robot are typically homogeneous,
meaning all units are identical. However, there are also heterogeneous systems that consist of
a variety of modules for greater versatility. Faı́ña et al. (2013).
Further, evolutionary algorithms have been investigated for generating self-assembling, self-
adapting, self-repairing, and self-reproducible behaviors of modular robotics. Adaptive modular
robots are known by these characteristics, which enable them to operate in unstructured and
hazardous environments. This section will briefly introduce the history of MRS and their
architecture based on the MITE framework.
2.2/ History and Architecture of Modular Robots
Generally, robots consist of two main components: control (brain) and morphology (body);
control is represented in many ways, including neural networks, which map sensory input to
actuator output. To enable open-ended synthesis, control and morphology should co-evolve
along with fitness functions and evaluation methods.
Versatility, robustness, and low cost are three of the promises of modular robotic systems.
(1)The MRS versatility comes from its ability to form a variety of shapes, each with many
Degree Of Freedom (DOF). It is the ability of a robot to self-reconfigure so that it can
accomplish a variety of tasks in a variety of environments; Versatility is measured by the
number of isomorphic configurations it can form and the number of DOF the robot has.
(2)The MRS is considered to be robust because of its redundancy and self-repair. Since it
is made up of many identical modules, if one goes down, the remaining modules can replace
it. (3)Also, with batch fabrication, low costs can be guaranteed. With increasing repetitions,
economies of scale take effect, reducing the per-module costs Yim et al. (2000). Keeping
low cost is also achievable through rapid prototyping equipment; such as 3D printing. As a
way to enhance the aforementioned characteristics in modular robotic systems, evolutionary
tasks-based design approaches are used as an alternative to traditional design techniques.
Robotic controls have become a hot topic in research because they are more adaptable than
the morphologies; Floreano et al. discussed the evolution of a small-wheeled robot that uses
a neural network and Genetic Algorithm (GA), to navigate loops. A focus group experi-
ment demonstrated that the fitness function evolved, as did the cruising speed of the robot,
which reinforces the idea that evolution can lead to better adaptations Floreano et al. (2007).
The book by Nolfi and Floreano offers a set of navigational experiments, ranging from very
straightforward to very complex, to illuminate different mechanisms of adaptation. By captur-
ing interactions between machine and environment that can’t be captured by a model-based
approach, the evolved solution displayed superior performance in certain cases. On the other
hand, more complex tasks exposed the limitations of reactive architectures Nolfi et al. (2000).
Previous research studies developed robotic controls for fixed morphological structures that
users designed. Further investigations indicate that they need to co-evolve robotic control and
morphology to produce more fit robots, just as nature does. A biped robot was evolved in
simulation using a coupled evolution of its shape and control parameters using a GA Paul et al.
(2001); the closed-loop recurrent neural network controller was optimized simultaneously with
the morphological parameters.
Through the introduction of coupled evolution and morphological control, complex systems
that would be difficult to design with traditional methods could be automated. Lipson and
Pollack explored concepts of automatic design by using motors and actuators without sensors;
neurons controlled the robots, while bars and linear actuators controlled the morphology. The
resulting solutions were remarkably elaborate and would have been much more challenging to
design using traditional methods Lipson et al. (2000); however, their manufacturability was
an obvious constraint. In order to build a wide variety of robotic structures, simplify the
search space, and ensure easy implementation, in reality, Faiña et al. proposed modular robot
structures as fundamental building blocks for evolutionary processes Faı́ña et al. (2013).
In 2000, Yang and Chen proposed the minimized degree-of-freedom concept for task-based
modular robot design optimization. Therefore, with fewer DOF, the modular robot can do the
task better in terms of energy consumption and loading capacity. The robot configuration is
represented by a matrix of assembly incidence. It uses evolutionary algorithms (EA) to search
for the optimal solution. A simulation of this algorithm had suboptimal results.
In 2001, Hornby et al. Hornby et al. (2001) proposed an automatic design system for modular
physical robots that could become more complex; The goal of their work was to reach high
complexities through generative design and simplify design changes by reusing modules; it
aimed to solve the limitations of an evolutionary design approach so that it may be applied
to practical engineering. Robots take cues from TinkerToy, with bars and joints modeled
after TinkerToy elements; the 2D robots are designed and optimized in simulations using
Lindenmayer’s system. After hand-assembling the actual robot, the work described how the
robot was developed for locomotion, together with the robot control system, and the work
produced a real robot that was moved in real life.
It was proposed in 2013 by Faina et al. to design heterogeneous modular robots using evolution-
2.2. HISTORY AND ARCHITECTURE OF MODULAR ROBOTS 17
ary algorithms; such a system is capable of designing complete robots, including their control
and morphology. They also proposed a distributed control architecture with heterogeneous
modules. Robotic morphology smooths the search space by using tree-like representations. In
simulation, the control and morphology of the robot will be co-evolved through a constructive
evolutionary strategy. After the robots are designed, the results are tested physically in order
to prove feasibility. The results of linear motion problems were promising, but static problems
needed improvements Faı́ña et al. (2013). A modular robot can be programmed with evolu-
tionary algorithms to use self-assembly from modules, self-reconfiguration into different forms,
self-repair based on errors and failures, and self-replication where one system can produce
another autonomous system.
Using Modular Robotic Systems (MRS) in various application domains brings up a slew of
difficult design, optimization, and planning issues, therefore recognizing the characteristics of
these issues is a crucial first step toward developing appropriate solutions. MITE is a framework
that has been proposed by Ahmadzadeh et al. (2016) that analyzes recent trends, research gaps
and limitations, as well as outstanding concerns in the field of Modular Robotic Systems (MRS).
The below section is heavily based on this MITE framework introduced by Ahmadzadeh et al.
(2016)
2.2.1/ Classification
Modular refers to something consisting of separate parts or units that can be joined together,
according to the Oxford English Dictionary. So, in essence, a modular robot is simply a robotic
body whose individual parts can be assembled to form a final body to perform a function.
The modularity of modular robots can be achieved in many ways, resulting in several different
classes of modular robots Murata et al. (2012b), including the fixed-configuration style, the
manually configurable style, and the self-configurable style. An autonomous robot within a
fixed-configuration class consists of identical or non-identical modules that have a certain level
of independence. Humans can add or remove modules from a manually-configurable modular
robot to increase its functionality. It is composed of an extensible, flexible morphology. Modular
robots that can reconfigure themselves independently without requiring human intervention
can change their configuration automatically. During the early 1990’s, researchers mostly
focused on two classes of modular robots, the first two categories of robots being the modular
form factor and the third class of modular robots being the modular manipulators, which are
composed of discrete joints and links and can be assembled in many different ways Chung et al.
(1997); Zhu et al. (2007). As autonomous systems became more important, attention shifted
to self-configurable modular robots, and most state-of-the-art works deal with the autonomous
self-configurable class of modular robots.
2.2.2/ Connections and Network
Modular robotics depends heavily on connectors in that they maintain connections between
modules while exerting shear forces. As it turns out, the strength of the connectors directly
influences the robustness of a modular robot’s structures; for example, lattice-based modules
can be made more solid in their final form, or chain-based modules can survive higher torques.
A connector can be characterized from three perspectives: Actuation, Geometry, and Mech-
anism. Connectors can be active or passive from the standpoint of actuation. Activated
connectors are equipped with hardware components, like motors and latches, that allow them
to maintain a secure connection between two modules. As opposed to an active connector, pas-
sive connectors are equipped with mechanisms for accepting or releasing connections. Passive
connectors, on the other hand, receive connections, while active ones initiate them.
An active connector can be connected to either an active connector or a passive connector, as

long as their surfaces match.
When looking at connectors from a geometric point of view, they are generally designed as
complementary shapes, i.e., male and female connectors (or, gendered connectors). Connec-
tors that increase symmetry among modules are called genderless connectors (also known as
hermaphrodite connectors). The connections of two genderless connectors, however, require
the control of two active connectors, making it more complex than that of connecting two
gendered active and passive connectors. As a result, each gendered connector requires only
one actuator for control and can make use of implicit alignment of link faces with the help of
guides embedded in the connection faces.
Connectors incorporate mechanisms to establish connections. This equipment is embedded in

modules to establish the connection. A connector’s mechanism includes magnetic (permanent
or temporary), mechanical, hydraulic, pneumatic, and absorptive elements. The mechanisms
are listed in the Connection Mechanism column. Magnetic and mechanical mechanisms are
the most commonly used connectors in modular robotics. They connect modules via magnetic
forces and latching mechanisms, respectively. RoomBots Sproewitz et al. (2009); Spröwitz
et al. (2014) consists of four halves spheres with ten mechanically active connections, and
UBot Zhao et al. (2011) is a cubic module composed of rotational joints using a magnetic
mechanism. The modular robots Pneumatic Inou et al. (2002) and Micro-Robot Tummala
et al. (1999) use pneumatic connectors: in the former, a pneumatic bellows provides pneumatic
connection to any of four ports embedded on the body, while a vacuum cup is used to connect
to walls. A hydraulic connector, such as one on a Stochastic 3D White et al. (2005) or a
Single-material Tolley et al. (2010) modular robot, has ports at the ends that conduct fluid
flow that exert hydraulic forces and assist modules faces in moving towards each other. Using a
relatively new connector mechanism called absorptive, groupings of modules can be connected
without explicit means of connections, but by binding forces that bind them together.
2.2.3/ Actuation
An actuator is a mechanic that is embedded in a module that provides either gait locomotion,
self-reconfiguration, self-assembly, or other functions. Module-based robots are controlled
by actuators, which create rotary and linear motions to provide them with basic low-level
functionality, such as:
• Rotation of joints,
• Latching and unlatching in active connection mechanisms
• Expansion and contraction of modules along a fixed axis (via telescopic linear actuators)
In typical modules, actuators occupy greater than 50% of the volume and weight White et al.
(2007), and so they pose a significant obstacle to module downsizing. Actuators, as in conven-
tional robots, are responsible for providing degrees of freedom to a modular robot and must
be capable of generating sufficient torques to control the modules chained serially to them.
This is a crucial point that makes embedding actuators into modular robots difficult, since
high-performance actuators make the modules heavier and larger due to their size, weight, and
energy consumption. Thus, a balance must be struck between the actuation capability of a
module and the weight and size of its actuators.
The most prevalent actuation mechanism is motors, which are available in a variety of forms.
It is less likely that a motor with a permanent magnet and winding stator will wear out than
one with a brushless direct current (BLDC) rotor. The drawback of such motors is that they
require expensive control electronics, such as Hall Effect sensors that sense rotor position and
provide the proper signals to trigger motor rotation. The high torque-per-weight and torque-
per-watt ratios of BLDC motors make them a common choice for modular robots. Modules
with brushless motors include Telecubes Suh et al. (2002), G2 Yim et al. (2003b), PolyBot Yim
et al. (2000), and Odin Lyder et al. (2008). Compared to BLDC motors, brushed DC motors
(BDC) tend to be easier to operate, since their brushes are energized when they are in contact
with the commutator when a current is applied. BDC motors are more expensive and easier to
control than BLDC motors, despite being less efficient and larger. Some modules use BLDC
motors, such as Roombot Spröwitz et al. (2014), SMART Baca et al. (2012), and M3Express
Wolfe et al. (2012). Stepper DC (SDC) motors also can be used to build modular robots,
especially if precision in the motor control is needed, but SDC motors are more complex
and less cost-effective than BDC motors. The modular robots X-Cell and ModRed Hong
et al. (2011); Dai et al. (2012) use SDC motors. The shape-memory alloys (SMAs) used in
solid-state actuators can be considered lightweight solid-state actuators since they return to
their original shape when heated. A SMA actuator’s response time is slower than that of a
motorized actuator since it must experience a cycle of heating, cooling, and deformation in
order to function. In addition, regulating the temperature of SMA actuators can be difficult
for modular robots operating in changing environments Yim (1994). SMAs are particularly
suitable for microscale actuators because of their small size and high shape recovery forces.
There are instances in modular robots where modules can rotate and move by means of SMAs,
such as in Miniaturized System Yoshida et al. (1999) and Cellular Slime Mold Lee et al. (2010).
Although SMAs can typically be found in connectors for actuating or releasing latches (as in
PolyBot Yim et al. (2000), CONRO Castano et al. (2000); Will et al. (1999), and M-TRAN
II Kurokawa et al. (2003)), there are instances where modules can move and rotate by means
of SMAs.
The electrostatic force between two charged objects can also be employed to generate actu-
ators. In macro-scale modules, electrostatic forces must be exerted at high voltages and the
electromagnetic impact diminishes with the function of the distance between side groups. Be-
cause charged bodies are so close together in microcosm, this concept is helpful. Two examples
of electrostatic actuation mechanisms implemented in modular robots include the development
of a latching mechanism between Claytronics modules Karagozler et al. (2007) and the devel-
opment of a configurations for the ”micro-scale MEMS” module Donald et al. (2006). Using
an electrostatic field instead of the Fracta module’s magnetic field mechanism, Murata et al.
(1994) proposed a ’Micro-scale Fractum’ module. It’s also worth noting that the traditional
method of providing actuation via mechanisms embedded within module hardware has been
replaced by a newer approach that appears to suggest that actuation capacity should not be
incorporated within the module’s body but rather given through foreign factors, thus trying to
remove the primary barrier to component reduction. In the case of external source actuation
works such as Kurokawa et al. (2002); Miyashita et al. (2008); Tolley et al. (2011b); White
et al. (2007), which mainly utilize motive forces in fluids or other viscoelastic environments to
start introducing Brownian movements in modules with unidentified self-assembly or reconfig-
uration times, Brownian motions can be introduced in modules with unfamiliar self-assembly
or reconfiguration times. There are certain hexagonal modules with magnetic connectors at
the edges placed on a table with vibrating motions in rhythm with the magnetic bonds and
module inertia, as proposed by White and Yim White et al. (2007). Magnetic pair bonds
can be broken and reconfiguration initiated in other edges by rotating this system’s modules
around one of their edges. The table’s synchronous motion causes the module to spin around
the edge connected to its neighboring modules. A rotation and subsequent movement to its
new location complete the process.
2.2.4/ Mobility
There are two modes for the Motion attribute: Deterministic and Stochastic Yim et al. (1997),
which govern how a module reconfigures and travels around in the workspace. Deterministic
reconfiguration is an advantage for most modular robots, including chain and lattice archi-
tectures, because it allows for specified workspace movements. As a result, modules can be
coded ahead of time and/or during a task’s execution. If a module’s mobility is stochastically
reconfigured, such as if it is floating in a fluidic environment, the path between two points
is supposed to be a random process analogous to Brownian motion. Stochastic reconfigura-
tion decreases the need for power supply, processing power, and actuation capabilities because
modules using this movement method can obtain their energy from the environment. Further-
more, this technique paves the door for micro and nanoscale modules to reposition, connect,
and detach utilizing environmental energy rather than the module’s own energy Tolley et al.
(2011b). Research on stochastic modular robots focuses mostly on the design of connection
mechanisms and self-assembly planning. A stochastic fluidic assembly system proposed by Tol-
ley et al. Tolley et al. (2011a) is an evolutionary approach to the evolution of a goal structure
from a large number of active components. Some more instances of stochastically moving
modules include Stochastic 2D cite25 white2004stochastic, Stochastic 3D White et al. (2005),
Programmable parts Bishop et al. (2005a), and Single Material modules Tolley et al. (2010).
Several bio- and chemo-inspired self-assembly planning approaches for stochastically-moving
modules are also examined, citing Hosokawa et al. (1994), Miyashita et al. (2008), Rothemund
et al. (2000), Shimizu et al. (2009), and Zykov et al. (2007b).
2.2.5/ Design
The most prevalent and well-known modular robot hardware architectures are Chain, Lattice,
Mobile, Hybrid, and Truss. Gilpin and Rus Gilpin et al. (2010b) developed free-form archi-
tecture to cover a few unusual systems that didn’t fit into established designs. Complex and
flexible structures like as strings, loops, and trees with many degrees of freedom are formed by
connecting several modules with limited Degree Of Freedom (DOF). Chain structures offer a
lot of versatility, but the representation, control, coordination, and computation that go along
with them are often fairly complex. Three-dimensional or two-dimensional lattice architecture
is made up of modules that can be organized into hexagonal or rectangular patterns in three di-
mensions (grids). When a lattice module needs to cross a grid cell, it relies on the cooperation
of its neighbors. Lattice systems are typically more convenient for modeling and addressing
reconfiguration planning problems than chain-based architectures because modules can take
advantage of highly abstracted representations like regular polygon cells and sliding-cubes, and
they can be operated in simultaneously.
Allowing modules in a mobile architecture to move around the environment on their own
is a key part of the design. A lattice or chain structure can be constructed by connecting
modules together. Mobile modules are swarm robots on wheels that can dock. With its three
independently propelled wheels and ability to join complicated chains and lattice structures,
the M3 Express is a self-moving modular robot.
Using struts that can stretch and contract, truss-based modules build truss-like structures.
modules include struts with variable or fixed lengths, as well as components that allow the
connection of many modules together. Hamlin et al. (1996) was the first module in this
design to have prismatic joints, which allowed all linkages to alter length. In either chain
or lattice structures, free-form modules don’t quite fit. They don’t need to form a regular
lattice structure to work well because they can build modules in semi-arbitrary spots.. Catoms
Kirby et al. (2005) and Slimebot Shimizu et al. (2005) are good examples of modules that
don’t require external components. With the help of Gilpin et al. (2010b), you may learn more
about Free-form modules. One other option is a combination of lattice and chain called Hybrid
architecture. This means that the chain module-specific gait movement can be used by hybrid
modules to construct lattice structures and connect to one other like chains. According to the
figure referred to above, the MITE framework for MRS architecture and characteristics can be
summarized in the following way:
Electrostatic
Hydraulic
force Free-form
Absorptive SDC motor

Truss
Expansion
Magnetic BDC motor
Self-Replicable Contraction Hybrid
Latching
Passive Genderless Pneumatic SMA External
Self-Reconfigurable Unlatching Mobile
Manually- Active Gendered Mechanical Rotation BLDC motor Internal

Stochastic Lattice
Reconfigurable
Fixed Configuration Actuation Geometry Mechanism Function Mechanism Source Deterministic Chain
Class Connectors Actuation Motion Architecture
Modular Robotic Systems
Figure 2.1: The MITE framework for characterizing Modular Robotic Systems Ahmadzadeh
et al. (2016)
2.2.6/ Multiple types of robots
As there are an increasing number of modular robotic prototypes in the literature, this section
describes a number of emphasized prototypes that participated in the research growth of
evolutionary modular robotics. The subsections are listed chronologically by publication date.
2.2.6.1/ PolyBot – 2000 - Xerox Palo Alto Research Center, Palo Alto,
CA, USA
Several generations of PolyBot modules were prototyped, each one with a number of im-
provements made to address the limitations of the previous generation. PolyBot is a modular
self-reconfigurable robot that was developed to explore how realistic it is to make robots using
generic hardware modules. A first generation (G1) node is a square prism with one rotational
DOF separating two ports, while a segment module is a rectangular prism with three rota-
tional DOFs. There are six connections available on each of the fixed passive cubes. For its
second generation (G2) connections ports, software controls the electromechanical latches, in
contrast to those in its predecessor. In third generation (G3) modules, the pins latch onto the
protruding pins on the opposite face. There is no DC motor on the outside of the modules.
This new module utilizes an internal harmonic gear and DC pancake motor; the connectors are
larger and have a stronger contact force for higher current load to enhance performance. Due
to software scalability and hardware dependency issues, PolyBot’s robustness has decreased
as the number of modules increases. However, the first two generations of PolyBot prove
versatility by moving over different terrains. Current PolyBot systems allow a maximum of 32
modules per system; each module has 1 degree of freedom. This system is capable of walking
like people, rolling like a snake, and moving like a lizard, or centipede in its third generation.
PolyBot is capable of self-reconfiguration by changing its geometry and locomotion mode de-
pending on the terrain type – rolling over flat terrain, earthworm to move around obstacles,
and a spider to step over hilly terrain. In many applications, a fixed set of configurations is
sufficient to permit self-collision-free motions, as the size of this space is exponential in the
number of modules and proportional to the number of DOF. It is also possible to preplan and
store reconfigurations off-line Yim et al. (2000) so that they can be executed easily if necessary.
2.2.6.2/ Telecubes – 2002 - Palo Alto Research Laboratories, Palo Alto,

CA, USA
The Crystalline system Rus et al. (2001) has an extension called the Telecube, which is a
compact cube. Each cube includes six prismatic DOFs and four sides that can expand more
than twice their length; The cubes may attach and detach magnetically to construct a self-
configurable modular robot Suh et al. (2002). It is expected that the original and final con-
figurations will overlap by employing a meta module during reconfiguration. A module is then
picked using the Minimum Manhattan Distance and a route is developed using a similar tech-
nique to PacMan for the selected module. Active modules and passive modules can be grouped
together during execution as soon as the path is established, allowing for a more efficient use
of resources. This reconfiguration approach performed worse when local decisions and parallel
execution were used instead of the active modules.
2.2.6.3/ M-TRAN – 2002 - National Institute for Advanced Industrial Sci-

ence and Technology, Ibaraki, Japan
Using 10 modules, the current M-TRAN robot successfully demonstrated the basic operation
of self-reconfiguration and motion generation. This piece of robotic technology is a distributed
lattice-based self-reconfigurable robot that can generate various configurations, including walk-
ing. Several software programs have been developed to control M-TRAN hardware, including a
kinematics simulator, an application for creating configurations and motion sequences, and an
automatic motion planner. Several improvements were made to M-TRAN II in order to allow
for versatile body movements and complex reconfigurations. Those improvements contain a re-
liable attachment/detachment mechanism, high-speed inter-module communication, onboard
multicomputer, accurate motor control, and low energy consumption. As well as verifying mo-
tions in dynamics simulations, the software has been enhanced to design self-reconfiguration
processes Kurokawa et al. (2003).
The third prototype (M-TRAN III) uses a distributed control system that provides multiple
control modes, including single-master, synchronous global control, and asynchronous parallel
control modes. The scalability and homogeneity of the system were maintained in all tests
involving self-reconfiguration experiments with units as large as 24 Kurokawa et al. (2008).
2.2.6.4/ ATRON – 2004 - Maersk McKinney Moller Institute for Roduction

Technology, University of Southern Denmark, Odense, Denmark
MOTE, a lattice-based system with roughly spherical modules, connects each sphere by an
infinite revisit joint, is another self-reconfigurable robot apart from ATRON, another self-
reconfigurable modular robot. Each module can rotate 360 degrees around the equator by
rotating around an axis diagonally through the sphere. In this design there is a lot of room
for mechanics, allowing very stable construction around the joints. In contrast, because the
basic module is spherical, connecting larger flat surfaces can be difficult. Because of the high
collision probability, spherical modules require connectors to establish essential contact between
modules, which is not desirable. A secondary effect of the mobility limitations of ATRON is the
use of ATRON’s meta-module to reduce the motion constraints. The meta-module is made
up of 3 components: a body at the center, a leg at either end and a grip at the top.
ATRON control module consists of three Artificial Neural Networks; one determines whether
the self-reconfiguration and self-repair processes will emerge, the second determines when they
will cease, and the third calculates the fitness value of every state. A Genetic Algorithm is
utilized to upgrade loads of the ANNs. Despite the fact that ATRON modules are moderate
since they have just one activated DOF, a group of modules was fit for self-reconfiguring in
3D recreation; Comparatively, ATRON modules exhibited self-repair effectively in reenactment
Østergaard et al. (2006); YIM (1993).
2.2.6.5/ Programmable Parts– 2005 - Department of Electrical Engineer-

ing, University of Washington, Seattle, WA, USA
On an air table, above oscillating fans sort triangular programmable components, which are
subsequently self-assembled into a variety of shapes using graph grammar mathematics, as
established in 2005 by Bishop et al. Magnets are used to communicate and selectively link
the modules without having a global understanding of the complete geometry. Due to design
limitations, only six of the planned 100 pieces could be manufactured. To demonstrate how
chemical systems respond, these six components were utilized in an experiment Bishop et al.
(2005a). A Markov Process Model Napp et al. (2006) based on kinetic rate data was developed
by Napp et al. in addition to prior graph grammar work.
2.2.6.6/ Y1 – 2006 - Universidad Rey Juan Carlos Madrid
Gonzalez-Gomez et al. created three Y1 module-based minimal configurations. Each of these

modules measures 72 52 52 mm and has one degree of freedom (DOF). They can attach and
detach. Polybot G1 modules inspired the Y1 module design. Then, using eight Y1 modules, a
modular worm-like robot with a wave propagation gait was built. Given velocity, stability, and
power consumption constraints, Genetic Algorithm is used to calculate the optimal parameters
of these designs, which include amplitude and phase Gonzalez-Gomez et al. (2006).
2.2.6.7/ Molecubes – 2007 - Cornell University, Schmidt Ocean Institute
The Molecubes system is a modular robotics open hardware and software platform that was
created to lower entry barriers and speed up progress. Modules with one rotational DOF
make up the system. Gripper, actuated joint, controller, camera, and wheel were among the
active modules on display, along with a variety of passive modules. Each module is a cube
with round corners that is made up of approximately two triangular pyramidal halves that are
connected at their bases so that their main axes are parallel. Each of the module’s six faces has
an electromechanical connector that can connect two modules. Symmetric connector design
allows for four different relative orientations of two connected module interfaces, resulting in
four different robot kinematics Zykov et al. (2007a). In order to generate a specific behavior
or motion, a genetic algorithm is used to evolve the modular neural network control of robots
in simulation Zykov et al. (2008). Path planning is done with a gene pool created using an
evolutionary algorithm Zhong et al. (2010) in order to achieve self-replication.
2.2.6.8/ Catom2D - 2009 - Carnegie Mellon University
Catoms are directly linked to the claytronics project. The word ”claytronics” originated from
both words clay and electronics Tucci et al. (2018); Thalamy (2020). In fact, this project is vast;
it began in Carnegie Mellon University and then was joined by FEMTO-ST institute/CNRS.
The objective of this project is to create millimeter scale robots that when assembled build a
large robot. A catom2D, Figure 2.2, is a 1 mm diameter module that can be manufactured
in large quantities. According to Karagozler et al. (2009) a unit should include only enough
functionality to contribute to the desired functionality of the ensemble. In order to simplify the
mechanism, conductive plates on the surface of the unit were used for movement, adhesion,
and communication. Electrostatic forces are the essential key for moving the robots around.
Figure 2.2: A real image of Catom2D, Karagozler et al. (2009)
2.2.6.9/ iMobot – 2010 - University of California, Davis, CA, USA
Ryland and Cheng created an intelligent self-configurable modular robot with four degrees of
freedom and six connection faces in each module. Individual modules in this robotic system
have complete mobility, in contrast to the other systems discussed in this paper, which require
modules to be connected in a cluster to perform all types of locomotion. For instance, the
M-TRAN module is capable of crawling but requires a second module to turn. Additionally,
the iMobot robotic system is capable of a variety of novel locomotion modes, including driving
and lifting into a camera platform Ryland et al. (2010). iMobot searches for the optimal
genotype capable of generating a particular robotic gait using a distributed agent-based Genetic
Algorithm Ko et al. (2010).
2.2.6.10/ UBot – 2011 - State Key Laboratory of Robotics and System,

Science Garden, Hit Limited, Harbin, China
UBot is a self-configurable modular robotic system with multimode locomotion capability.

Cross, loop, quadruped, and other gaits are all modes of locomotion. UBot is a hybrid system
that combines the benefits of self-configurable lattice and chain robots. Each module is cube-
shaped and has two rotational joints to achieve two degrees of freedom Zhao et al. (2011,
2012). In 2013, researchers developed a three-dimensional dynamic simulator for simulating

rigid body dynamics and evolving robotic locomotion. The gait planner for various robotic
structures was discovered using evolutionary robotics Zhu et al. (2013).
2.2.6.11/ Blinky Blocks – 2011 - Carnegie Mellon University
Blinky Blocks are centimeter-scale blocks developed as part of Carnegie Mellon University’s
Claytronics project Kirby et al. (2011). These blocks enable the deployment and testing of
distributed algorithms on hardware platforms. They are more manageable than millimeter-
scale catoms due to their size. Additionally, they are inexpensive, allowing algorithms to
be evaluated on ensembles of dozens of units. This allows for the assessment of ensemble
programming’s emergent properties. Blinky Blocks have evolved through multiple generations.
The most recent was created in collaboration with the FEMTO-ST research institute by the
Tech Power Electronics company. FEMTO-ST did a lot of research on modular robotics and
tested them on blinky blocks such as: Bassil et al. (2020), Naz et al. (2018b), Piranda et al.
(2021), Thalamy et al. (2021). Each module contains its own processing power, as well as
sensors and actuators such as RGB leds that can be programmed to glow in various colors.
Blocks are capable of sensing their current orientation as well as external stimuli such as
shaking or tapping. Additionally, they are capable of playing and recording audio. Each of a
system’s blocks executes the identical program. Magnets connect them. A block may have up
to six neighbors with whom he may communicate via serial links located on the block faces
(neighbor-to-neighbor communication model). Connecting a single block to a power supply
is straightforward. Dedicated pins are used to distribute power across the system. Manual
reconfiguration of Blinky Block ensembles is possible: users can plug and unplug units during
runtime to enable behavior changes based on new physical groupings. In 2021, the OMNI
team at FEMTO-ST institute broke the record for the largest modular robot composed of
1,824 modules made from Blinky Blocks.
2.2.6.12/ SMORES – 2012 - University of Pennsylvania, Philadelphia, PA
Self-assembling Modular Robot for Extreme Shapeshifting was developed to be a universal

modular robot that increases the versatility of self-configurable robots by allowing them to re-
configure in three reconfiguration classes: lattice, chain, and mobile. Each module is equipped
with four active degrees of freedom of rotation and two wheels for mobility Davey et al. (2012).
In 2018, a framework for configuring SMORES robots was developed to make the process eas-
ier. By detecting conflicting commands and loss of stability, the proposed system verifies the
validity of robotic design. Additionally, this system enables the reusability of existing robotic
structures to generate complex robotic designs and behaviors Tosun et al. (2018).
2.2.6.13/ Catom3D - 2018 - FEMTO-ST
Catom3D is an advanced version of Catom2D. It is a simple module that can be manufactured

in large quantities. All those micro robots will then assemble to create an object of any size
or shape. Unlike Catom2D, Catom3D can move in three dimensional space. Moreover, it is a
spherical shape module with a sub-mm diameter as shown in Figure 2.3 . Catom3D contains
a chip to process sensors and actuators. Piranda et al. (2018)
(a) (b)
Figure 2.3: Catom3D

(a) (b) (c)
(d) (e) (f)
(g) (h) (i)
Figure 2.4: Examples of modular robots: Figure 2.4a represents a polybot introduced in Yim
et al. (2000); Figure 2.4b is a Tripod configuration of CONRO Castano et al. (2000); Figure
2.4c is a Five YaMoR modules Moeckel et al. (2006); Figure 2.4d is a lattice modular robot
called ATRON Jorgensen et al. (2004); Figure 2.4e is a Rotating M-Block Romanishin et al.
(2013); Figure 2.4f is a 2D Crystalline Rus et al. (2000) modular robots with extensible arms;
Figure 2.4g is a Superbot Salemi et al. (2006) modular robot in a humanoid configuration.
Figure 2.4h M-TRAN Kamimura et al. (2002) modular robot in 4-legged configuration; Figure
2.4i is a SMORES Davey et al. (2012) modular robot.
Robots Year Self reconfig. Actuation Genderless DOF

PolyBot 2000 Yes DC Motor No 1
Telecubes 2002 Yes DC Motor Yes 6
M-TRAN 2002 Yes DC Motor Yes 1
ATRON 2004 Yes DC Motor Yes 1
Programmable Parts 2005 No - No 0
Y1 2006 No DC Motor No 1
Molecubes 2007 Yes DC Motor Yes 1
IMOBOT 2010 No DC Motor Yes 1
UBOT 2011 Yes DC Motor Yes 2
BlinkyBlocks 2011 No - Yes 0
SMORES 2012 Yes DC motor Yes 4
Table 2.1: Characteristics for different types of modular robots.
2.3/ Modular Robots Characteristic
2.3.1/ Symmetry
The number of configurations that a modular robot may generate is directly affected by module
symmetry, which might be geometrical (i.e., in shape) or functional (i.e., in connection ports).
Geometric symmetry generates isomorphic (topologically identical) configurations, lowering
the number of unique configurations and, as a result, the size of Configuration space (C-
space). Functional symmetry, on the other hand, is concerned with the kinematic symmetry of
modules, with a module having functional symmetry if its kinematic qualities remain constant
as it rotates around different axes. Park et al. Park et al. (2008) showed that the number
of various ways in which n modules can interconnect has an upper bound of (cw)n for a
homogeneous modular robot with c connection ports and w ways of connecting, because each
module can connect in w ways to c(n-1) modules. Due to the lowering of the parameters c and
w when symmetry is considered, the total number of different configurations is much fewer
than the upper bound. Asadpour et al. Asadpour et al. (2009) proposed the symmetry factor
to simplify the representation of MRS by the use of symmetry. It is defined as the number
of unique rotational rotations that maintain a module’s spatial orientation. For example,
the Molecube module has a symmetry factor of 24, which implies it can be flipped in 23
various directions while maintaining its spatial orientation. The way configuration diagrams
are represented is affected by module symmetry. Chen and Burdick Chen et al. (1998) described
a symmetrical rotational grouping as the set of rotations that transfer a module to itself, and
2.3. MODULAR ROBOTS CHARACTERISTIC 31
they represented configurations using the Assembly Incidence Matrix (AIM). They employed
network isomorphism and symmetric rotational groups to construct equivalence connections
on the s, then used the Polya’s Enumeration Theorem to compute the amount of equivalence
classes, or unique configurations.
Relying on their symmetry properties, Murata and Kurokawa Murata et al. (2007) categorized
modular robots into anisotropy (similar to interlayer modules) and anisotropic classifications
(like chain and mobile modules). An isotropic subsystem, namely the Rhombic Dodecahedron
molded modules in Yim et al. Yim et al. (1997), exhibits the same properties when tested
in different directions, whilst the characteristics of an anisotropic architectural style, including
the vast bulk of chain-based modules, display systematic variation.
2.3.2/ Scale
The scale attribute is associated with the physical measurements of modules, which range from
huge modules generated at centimeter and millimeter scales (i.e. macro scale) to microscopic
scheduling method at fractions of a millimeter scale (i.e. micro scale) and even nanoscale
scale (i.e. nano scale). Most typical modular robots are designed on a macro size, and
they regularly connect to one another and change configurations via a self-reconfiguration
procedure. Micro-scale modules are constructed on the dimension of biological cells, which
could be as small as 2 micrometers for bacteria and as large as 20 micrometers for multicellular
organisms. Despite recent substantial reductions in the scale of electronic components such
as transistors and microprocessors, the design of micro-scale modules, which limit the size of
modular robots, remains a difficult challenge due to technological limitations in manufacturing
micro-scale sensors and motors. However, by reducing the size of modules, their capabilities
are also lowered. As a result, the present hardware challenge is centered on shrinking the size
of embedded systems modules while preserving adequate capabilities Murata et al. (2012a).
In fact, the dimensional restrictions of their fundamental components, such as actuation,
batteries, and connection mechanisms, limit the size of mechatronic modules. However, one
method for scaling down modules is to decouple actuators and batteries from modular and have
the environment fulfill motion and energy requirements. For example, Fu et al. (2012) designed
a particular micro connection system for connecting, aligning, locking, and detaching modular
robots by leveraging elastic alloys that can switch connection function on or off. Donald et
al. Donald et al. (2006) presented a microelectromechanical system (MEMS), which is a
rectangle (260x60 µm) module capable of moving over a substrate with embedded electrodes.
Its attachment mechanism consists of a 100 µm raised tail that is attached to the substrate in
reaction to a specified voltage. Tolley et al. Tolley et al. (2008) created silicon tile modules
with dimensions of 500x500x30 µm in width, height, and thickness, and outfitted them with a
singular passive latch on each side as a connecting mechanism. They demonstrated the ability
of such modules to self-assemble in a fluid environment.
Nano modules construct molecular devices from artificially generated molecules. In DNA tech-
nology, the DNA molecule has a diameter of 2 nm and is actually referred to as a programmable
material. It has been used to successfully produce nanometric structures. Both 2D Rothemund
(2006) and 3D Shih et al. (2004) nanostructures have been successfully created using the DNA
Origami method. Yurke et al. Yurke et al. (2000) developed tweezers made of DNA molecules
that can be used as operators for nano-scale modules. Because those modules lack inbuilt
actuators and power supplies, they must rely on the environment to meet their energy needs.
These modules are activated by environmental forces (such as flotation in a fluidic environ-
ment) and self-assemble to change configuration. The scale of a module has a direct effect on
how a modular robot accomplishes its assigned tasks. The size characteristic, for example, de-
termines the desired final configuration, such that in micro-scale MRS, homogenous structural
patterns are largely sought, whereas in macro-scale MRS, the formation of low-scale structures
with desirable functionality is realized Kernbach et al. (2011).
2.3.3/ Structure
If a robotic system can only move down a line, on a plane, or in space, it is said to have linear,
planar, or spatial structure. Two elements influence the structure of an MRS: system configu-
ration and module mechanics. For example, M-TRAN modules are linear when configured as
a circuit or snake Kurokawa et al. (2002), planar once configured as a multi configuration, and
structural when configured as a grouping of modules that circulate in workspace Fitch et al.
(2013), Kurokawa et al. (2002), Kurokawa et al. (2000). Fracta modules (Murata et al. 1994),
on the other hand, can only build planar structures in whatever arrangement they form since
they lack movement along the z-axis. Such that, they lack a mechanism for climbing over one
another. Table 2.1 depicts the most complicated structure that every module is capable of
achieving.
2.3.4/ Homogeneity
Essentially, this aspect tends to refer to the existence of modules in an MRS that are either
identical or dissimilar in their features: an MRS was shown to be homogeneous if all of its
classifying modules have the same geometrical and functional characteristics as well as the
same computing power, actuating functionality, and so on; an MRS is said to be diverse if all
of its constituent parts modules have markedly different capabilities and the same geometry and
functional characteristics. It is easier to plan for the achievement of a goal configuration when
all modules are identical since any module can inhabit any slot in the configuration, enabling for
more straightforward hardware and software to perform the planning work. As a result of the
heterogeneity of MRS, it becomes more versatile, but at the expense of increased hardware and
software ambiguity: strategic plan becomes more challenging in heterogeneous MRS because
2.4. APPLICATION AREA 33
the diversity imposes restrictions on the locations of specific modules particularly in comparison
to other modules, making it more difficult to design the system. Example scenarios include
situations in which a motorized module can only be positioned at the ends (limbs) of a tree
structure or in which a module supplied with batteries can only be placed at hub points. These
limits must be taken into account by the self-reconfiguration planner in order to maximize
the use of special-purpose modules not just in final configuration but also in transitional
configurations in such instances. Baca et al. Baca et al. (2012) constructed customized power,
control, and joint modules then combined them physically into leg-based, wheel-based, as well
as mechanical arm configurations, among other things. They made use of such combinations
for both manipulation and movement in their work. Brunete et al. Brunete et al. (2011)
developed camera, interface, rotation, inchworm, and helicoidal modules featuring variable
motion capabilities for use in pipe inspection applications, as well as a camera and contact
module. An asynchronous empirical method that can realize diverse gaits for movements inside
pipes was developed with the help of the Genetic Algorithm (GA). Moreover, the work of Fitch
et al. Fitch et al. (2003) looked into a diverse lattice-based MRS.
2.4/ Application area
Manufacturing, medical, environmental monitoring, entertainment, and a variety of other fields

can all benefit from programmable matter. Programmable matter will enable a wide range of
applications in the future, from developing robots and assisting in human activity control to
engineering microelectromechanical systems and even producing materials with unknown prop-
erties. Where would a modular self-reconfigurable system be employed, given these benefits?
While the system promises to be capable of a wide range of tasks, identifying the ”killer
application” has proven difficult.
2.4.1/ Space exploration
Long-term space missions are one application that illustrates the benefits of self-reconfigurable
systems. These necessitate a long-term self-sustaining robotic ecology capable of dealing
with unanticipated circumstances and maybe requiring self-repair. Self-reconfigurable systems,
in comparison to fixed configuration systems, can tackle jobs that are unknown in advance.
Furthermore, space missions are severely limited in terms of volume and bulk. Sending a robot
system that can reconfigure to perform several jobs rather than sending many robots that can
only perform one activity might be more effective. Telepario
2.4.2/ Telepario
Todd Mowry and Seth Goldstein of CMU invented the term ”telepario” Goldstein et al. (2005)
to describe another type of application. The researchers want to create moving, tangible,
three-dimensional representations of people or things that are lifelike enough for human senses
to perceive them as genuine. This would reduce the need for bulky virtual reality equipment
while also overcoming the viewing angle constraints of current 3D methods. The copies would
take on the shape and look of the person or item being photographed in real time, and they
would follow the originals’ movements. One feature of this application is that the focus is on
geometric representation rather than transferring forces to the environment, as is usual with
robotic manipulation.
2.4.3/ Bucket of stuff
”Bucket of things” is the name given to a third long-term goal for these systems Karagozler
(2012). Consumers of the future will have a container of self-reconfigurable modules in their
garage, basement, or attic, according to this idea. When a need occurs, the customer summons
the robots to do a work such as ”cleaning the gutters” or ”changing the oil in the automobile,”
and the robot takes on the required shape and completes the operation.
2.4.4/ Medical Application
There is a clear trend toward miniaturization of medical devices for minimally invasive medical
procedures ranging from diagnosis and targeted drug delivery to complex surgical interventions.
Current research focuses on improving the functionality of commercially successful capsule
endoscope technology through the development of active locomotion and telemetry. The size
of such a capsule should not be larger than what a person can swallow without difficulty.
Building a modular robotic system in which the modules are swallowed one at a time and the
final assembly is performed inside the gastrointestinal (GI) tract is one approach to increasing
functionality while remaining within this size constraint. In their paper, Zoltan Nagy et al.
Nagy et al. (2008) address a fundamental challenge that must be overcome for such swallowable
modular robots to succeed: their self-assembly. They proposed using magnets in a specific
configuration on the mating faces of the modules. Their findings demonstrated that high
success rates are possible, and snake-type robots can be self-assembled with compliant magnetic
joints, allowing them to adapt to highly irregular paths such as the small intestine.
2.5. CHALLENGES 35
2.5/ Challenges
2.5.1/ Self-Assembly
As part of modularity, self-assembly is one of its greatest benefits, since self-assembly is the
process of building complex multi-unit systems utilizing simple governing elements. This self-
assembly tendency is widespread in nature and accounts for much of the functionality of living
cells Bishop et al. (2005b). It is uncommon in the technological field due to its status as a
relatively new concept compared to its application in the other fields, even though it could help
lower costs, improve versatility, and increase robustness, which are the promises of modular
robotics. Self-assembled robots can perform tasks in remote or hazardous environments due
to their ability to assemble larger, stronger machines using smaller modules.
To put it differently, self-assembly entails creating a collection of elements with edge-binding

properties such that, if they mix randomly, they form the desired assemblies. It is possible
for elements to possess fixed or dynamic binding properties as well as a variety of capabilities,
such as the ability to detect binding events or exchange information with their neighbors Werfel
(2006). Evolutionary algorithms are utilized in the design of self-assembled modular robotic
systems; Bonabeau et al. investigated the use of GAs for self-assembly rules and investigated
their relationship with biologically plausible structures. A problem with self-assembly following
predetermined shapes was not addressed by this work Bonabeau et al. (1999). In White
et al. (2004), Tolley et al. extended the stochastic self-assembly modular robot from 2D to
3D; they applied an evolutionary approach to determine the shape of the robot structures.
Simulations are used to evolve these structures using frequency-based representation; then,
assembly algorithms are used to pick the fittest robot assembly path by taking a sample of all
possible paths to the target structure and following the one that leaves the most choices open.
It is impossible for this system’s modules to move independently because they must circulate
in turbulent fluids to accrete onto the structure. This liquidic system might be scaled down to
produce micro-scale modules. A feedback system between design and assembly would improve
the flexibility of the system, allowing it to adapt to assembly conditions and have a significant
impact on the evolving design.
The authors Tucci et al. (2018) focused their research on modular robots made up of numerous
homogeneous modules with minimal processing capabilities that may change the way their
modules are connected by releasing or docking part of them to form a specific shape, resulting
in intelligent matter. They concentrated on resolving the issue of building 3D constructions with
interior holes. Modules dock in accessible locations while the structure is being built, although
some positions may become impossible to reach due to other modules blocking them. Three
steps make up their algorithm. The first stage is to build a spatially efficient description of the
final scene and transfer it to a seed module within its location on the representation. The second
phase is to structure the plane construction, with the first structural goal being a solution for a
two-dimensional lattice. Finally, the third step is to synchronize the two-dimensional solutions
in order to obtain a three-dimensional representation.
2.5.2/ Self-reconfiguration
Modules for modular self-reconfigurable robots should be able to combine themselves au-
tonomously into meta-modules that can perform various tasks under different circumstances
Faı́ña et al. (2013); White et al. (2005). In recent years, modular robotics has received attention
from researchers in the robotics field due to its ability to self-reconfigure. Self-reconfiguring
robots can take on different forms, which allows them to perform different kinds of kine-
matics; for example, they can become manipulators, crawlers, or walkers White et al. (2005).
Self-reconfigurable robots with this adaptability are capable of working in unstructured environ-
ments, including space exploration, deep-sea missions, rescue endeavors, and reconnaissance
Yim et al. (2002a). The first two categories of reconfigurable robots were based on how they
reconfigure. The third class of reconfigurable robots was based on deterministic and stochastic
reconfigurations in 2007 Yim et al. (2007).
In a lattice architecture, modules are arranged in a grid of 2-dimensional or 3-dimensional

coordinates, and this grid can be used to determine module positions and form a new form
accordingly. In addition to simplifying planning and controlling, lattice architectures can also
reduce reconfiguration time compared to other types of architecture because control and motion
can be done in parallel White et al. (2005). A lattice-type system helps self-reconfiguration
by exploiting lattice regularity in aligning connectors. However, we must assume that all
modules conform to the lattice, and this can pose a problem if there are a large number of
modules Østergaard et al. (2006). Robots based on lattices for self-reconfiguration have been
demonstrated, such as M-TRAN Murata et al. (2002); Kurokawa et al. (2003).
Unlike the string or tree topologies of Chain/Tree architectures, each chain of modules is
always connected to the rest of the chain at least one time, and the modules reconfigure by
connecting and detaching from one another. Besides their capability to reach any location in
space, chains are more versatile than other architectures since they can be used for arms, legs,
or tentacles; however, chains are more difficult to control and more costly to represent and
analyze than other architectures White et al. (2005). Among self-reconfigurable robots based
on chains are PolyBot Yim et al. (2003a, 2000).
Several systems can both have lattice architectures and chain architectures simultaneously, e.g.
SuperBot Yim et al. (2002b) and UBot Zhao et al. (2011) have hybrid architectures Yim et al.
(2002a). Mobile architectures are built with modules that detach and move independently
using the environment (e.g. liquids or space) to create new shapes, intricate lattices or chains,
or to link up with other modules to form smaller robots. A mobile-based self-reconfigurable
example system is CEBOT Fukuda et al. (1990, 1991). Mobile architectures have received
2.5. CHALLENGES 37
less attention than other structures due to their reconfiguration difficulty Yim et al. (2002a,
2007). For deterministic architectures, modules move directly to their target locations dur-
ing self-reconfiguration; one can know an individual unit’s location at any time or calculate
it at run time to guarantee reconfiguration timing. Normally, macro-scale systems are con-
sidered deterministic, since they require feedback control to maintain precision. Statistical
Architectures include modules moving in a 2D or 3D environment using statistical methods,
such as Brownian motion, which is used to guarantee reconfiguration times. Nevertheless, the
path taken by each unit to reach location A may not be known until the unit is connected
to the main structure. Micro-scale systems are better suited to stochastic architectures; this
is because the environment can provide most of the energy needed for moving units around
Yim et al. (2007). In order to support self-reconfiguration and implement different modular
robotic behaviors, evolution algorithms were applied to develop modular self-reconfigurable
robotic controls; Stergaard and Lund explored evolving controllers for M-TRAN Ostergaard
et al. (2003) and ATRON Østergaard et al. (2006) self-reconfigurable modular robotic systems
in simulation. For example, the implementation of M-TRAN walking behavior requires the
use of GAs since the conditions of neighboring modules affect local evolution to yield a global
behavior. Because of this, when the ATRON controllers were evolving individually to allow
the modular collection to move forward, two modules were evaluated together rather than
evaluating each module separately, and no consideration was given to the limitations of the
physical system. Modular self-configurable robot ACMoD uses GA to generate configuration
patterns and to optimize module paths through a static grid of various terrain blocks; this work
has not taken into account dynamic environments or found optimal solutions. The procedure
was executed in simulation Klidbary et al. (2013).
In their paper Thalamy et al. (2019a), the authors proposed a scaffolding-based method for
accelerating self-reconfiguration in order to build a porous version of the desired shape. He
extended this concept by proposing a method for building a parametric scaffolding model that
increases the parallelism of the reconfiguration, supports its mechanical stability, and simplifies
agent planning and coordination. Each agent has a set of basic rules that use only four states,
ensuring that module movements and scaffold construction are deterministic. When combined
with an underneath reserve of modules that allows the introduction of rotating quasi-spherical
modules at various ground locations of the growing porous structure, his method can construct
the scaffolding structure in O(N 2/3 ) time, where N is the number of modules that comprise
the structure.
Another reconfiguration challenge was solved in El-Baz et al. (2014) where the authors pro-
posed a scalable distributed iterative algorithm. In fact, this algorithm is able to solve the
discrete trajectory optimization problem using the MEMS-based reconfigurable modular con-
veyor. Moreover, the blocks communicate among each other in order to find the shortest path
for the parts on the surface.
Another challenge in the self-reconfiguration area is the hardware itself. The mobility of the
modules is highly based on the efficiency and effectiveness of the hardware. The more robust
the connection is, the better the reconfiguration. The authors in Zhu et al. (2019) proposed a
new type of millimeter scale actuator based on simplified electropermanent magnets. Analysis
based on numerical simulation is used to develop the prototype. A controllable H-bridge with
dead time and its reusable design is proposed to control the new actuator and simplify the
electronic circuit. Finally, the new actuator is implemented in a DILI modular reconfigurable
robot system. Test results show that with this new actuator, the DILI module can move
smoothly and connect to other modules without power. The maximum speed of the DILI
module is 20 mm/s.
2.5.3/ Self-Repair
In self-repair, modules that break can be replaced by working ones so that the robot can
continue its work. The self-repair system should have two principles: it must be able to repair
itself, and it should be able to obtain new parts easily. Because of this, self-repairing modular
robots generally consist of redundant modules. Self-repair entangles two stages: the detection
of the failure module, and then the ejection of the deficient module and the substitution
of it with an efficient module; Such robots are well fitted for functioning in unfamiliar and
distant surroundings. Evolutionary algorithms are used by ATRON modular robots to execute
self-repair functionality Østergaard et al. (2006). This system is examined in detail in the
Applications faction in this paper.
2.5.4/ Self-Reproduction
A self-replicator is an advanced form of self-repair in which robots reproduce themselves using

simple rules from an infinite source of parts. If the resulting system is a replica of the original,
the system is known as a self-replicator. Creating self-replicating robots involves building tiny
seed systems that grow exponentially into larger systems over tens of generations. The resulting
robots are capable of accomplishing extremely large-scale tasks, including recycling solar energy,
removing greenhouse gases from the atmosphere, and purifying water for irrigation. Since
self-assembly requires an external material supply, some of the lattice positions may serve as
dispensers, where new modules show up when the current ones are removed. This is unlike
self-production where the resulting systems do not need to duplicate themselves in the latter
case. Self-replication is categorized into the following kinds Ostergaard et al. (2003):
• Direct reproduction: A robot picks pieces from a dispenser and attaches them to new
locations to create a copy from scratch.
• Multi-parent reproduction: Two robots place components, and the third assembles them
2.5. CHALLENGES 39
to form one copy.
• Self-assisted reproduction: The robot assisting its construction automatically reconfig-

ures itself during the process.
• Multi-stage reproduction: As part of the construction process, a temporary scaffold is

manufactured; then the temporary scaffold is discarded as waste or repurposed to produce
additional robots.
It is possible for self-replicators to evolve into goal structures by using evolutionary algorithms.
The evolution of Molecubes in 2D simulation occurs in two steps: evolution of morphology
and evolution of control; Zykov and colleagues used Genetic Algorithms to evaluate fitness,
evaluating morphology and controlling control separately. The genome used described the
robotic structure, while command sequences described the control; Only a few results yielded
two identical copies, and the matching control was implemented on real robots; This work
faces the challenge of creating self-replication algorithms.
2.5.5/ Self-sufficiency
Self-sufficiency is an attribute that indicates the level of embeddedness of hardware commodi-

ties and how much a module is equipped with various components such as processing units,
power supplies, sensors, actuators, and so on ?. A module with a high degree of self-sufficiency
can operate untethered or independently, whereas a module with a low degree of self-sufficiency
is usually tethered, meaning it cannot operate without the assistance of supplies from the en-
vironment or other modules. The PolyBot G2 reconfigurable robot, for example, is made up of
segment and node modules that are tethered to a power supply Yim et al. (2003b). Tethers for
power supply and control signals are significant impediments to reconfiguration processes and
severely limit self-reconfiguration planning Kurokawa et al. (2003). While it may appear that
adding a battery to a previously tethered module does not fundamentally change the module
in terms of hardware, such an increase in self-sufficiency has implications for the entire MRS
system. It loosens many constraints in self-reconfiguration planning, such as keeping tethered
modules connected to the robot’s main structure in order to provide power supply.
2.5.6/ ID Assignment
As previously described, programmable matter is made from small modules put together.
Therefore, the idea of having different identification for the modules is very hard. Unlike
traditional computing devices —computers, mobile phones, tablets, and others —, modular
robots cannot have a unique identification like a MAC address or a physical address. This is
due to their memory limitation and large number. Unique ID are crucial for better commu-
nication among the modules. This also makes developing software easier and more secure.
Therefore, due to the large number of particles it is almost impossible to manually assign a
unique ID to each particle. It is up to the particles to assign themselves each a unique ID in
a distributed and memory/energy efficient manner. In their paper Assaker et al. (2020), the
authors proposed a distributed unique ID assignment method for modular robots. It is a three
phases based algorithm. The first phase consists in discovering the system while building a
logical tree. The second phase finds the total size of particles in the system needed for several
operations in modular robots, and the third one is dedicated to the unique ID assignment. Af-
ter fully optimizing the distributed algorithm, the effects of various system shapes and leader
positions on the energy and time complexity are studied, while proposing fitting solutions for
different requirements.
2.5.7/ Leader Election
Among the various concrete manifestations of programmable matter, the amoebot model, first
proposed by Derakhshandeh et al. Derakhshandeh et al. (2014a) (also explained in detail by
Daymude et al. Daymude et al. (2019)), has gained considerable attention in recent years. In
this model, each particle can move like an amoeba from one grid point of a triangular grid to
another. Many interesting problems were addressed, such as material coating Daymude et al.
(2018); Derakhshandeh et al. (2017, 2014b), bridge construction Andrés Arroyo et al. (2018);
Daymude et al. (2021), energy distribution Daymude et al. (2021), shape formation Cannon
et al. (2016); Derakhshandeh et al. (2016); Luna et al. (2020); Di Luna et al. (2020), and shape
recovery Di Luna et al. (2018). A dominant strategy for solving these problems has been to
select a unique leader among the particles, who then coordinates all movements. The ability
to move was not used as an aid to computation and communication in early deterministic
leader election algorithms. This resulted in algorithms that were based on assumptions about
the particle system’s initial shape (intuitively, that it had no ”holes”) Di Luna et al. (2020);
Gastineau et al. (2018) or elected up to 6 leaders instead of one in some cases Bazzi et al.
(2019). Recently, it was demonstrated that the movements of the particles could be used to
elect a single leader (or up to three leaders when actions are not atomic) without imposing any
constraints on the initial shape D’Angelo et al. (2020); Emek et al. (2019). Unfortunately, the
improvements mentioned above came at the expense of a significantly longer runtime when
compared to algorithms that assumed no holes.
2.5.8/ Security
Modular robots can be used in unattended, even hostile environments, making them vulnerable
to both passive and active attacks. For example, if a space shuttle module is hacked and
begins sending false coordinates, or if a nano robot is injected into the human body and begins
killing healthy cells, the shuttle will crash. As a result, security is essential in such scenarios,
2.6. ETHICS IN MODULAR ROBOTS 41
particularly in the context of modular robots, where modules have limited resources and are
vulnerable to physical capture. Researchers have not yet addressed the issue of security in
modular robots, to the best of our knowledge. When discussing such topics, many difficulties
arise. This type of robot lacks centralized control and has limited memory and processing
power. Traditional security protocols are inapplicable in such circumstances. Lightweight
security protocols must therefore be proposed and researched. Such protocols have been
proposed in the context of wireless sensor networks Guyeux et al. (2014); Santos-González
et al. (2020); Bahi et al. (2010), ad hoc networks Ogundoyin (2020), and the Internet of
Things (IoT) Sarker et al. (2020); Wazid et al. (2020). Although modular robots are classified
as an IoT application, they have some distinguishing features. They can’t have a unique
identifier or IP addresses, for example. Furthermore, they are not always connected to the
internet and lack centralized management. As a result, existing IoT security protocols for
programmable matter cannot be used.
2.5.9/ Clustering
Clustering the modular robots system is one solution that may simplify the self-reconfiguration
problem. Assembling particles into clusters and carrying out tasks in cluster-based approaches
can improve efficiency in terms of execution time and energy consumption. As a result, clus-
tering the particles in modular robots has numerous advantages, including scalability, energy
efficiency, and improved routing and communications. In fact, the cluster is made up of a group
of nodes, and the local interactions between cluster members are handled by a leader cluster
head (CH). A CH’s job is to schedule activities in the cluster. Modules would be concerned
only with selecting its CH and would be unaffected by changes at the inter-cluster level, so
cluster members communicate with CH and data is collected and aggregated by CH, limiting
the scope of inter-cluster interactions to CHs only and avoiding the transmission of redundant
messages among modules. It is critical to have an efficient encoding of the goal shape de-
scription, which will eventually be useful in determining the number of clusters. Tucci et al.
(2017) proposed an efficient scene encoding method based on Constructive Solid Geometry
(CSG) Requicha et al. (1977) in Tucci et al. (2017), which defines a tree of objects that can
be combined to form the final scene. The tree can be represented compactly and efficiently
stored in each module. The number of clusters can be calculated by counting the number of
objects on each level of the CSG tree.
2.6/ Ethics in Modular Robots
One of the key challenges that must be addressed in the field of modular robots and pro-
grammable matter is the potential ethical and social implications of these technologies. As
modular robots and programmable matter become more advanced and widespread, they are
likely to have a significant impact on a wide range of industries and applications, potentially
leading to changes in the way we live and work.
One of the key ethical challenges associated with modular robots and programmable matter is
the potential impact on jobs. As these technologies become more advanced and efficient, they
may replace human workers in a variety of tasks, leading to job losses and potentially increasing
inequality and social instability Etemad-Sajadi et al. (2022). This is particularly concerning in
industries such as manufacturing and construction, where modular robots and programmable
matter could potentially replace large numbers of human workers.
Another ethical challenge associated with modular robots and programmable matter is the
potential impact on privacy and security. As these technologies become more widespread, they
are likely to generate vast amounts of data, potentially exposing individuals to surveillance and
other forms of privacy invasion. In addition, modular robots and programmable matter could
potentially be used for malicious purposes, such as surveillance, hacking, or sabotage. This
raises concerns about the need for effective regulations and safeguards to protect privacy and
security.
Finally, there is also a potential ethical challenge associated with the use of modular robots and
programmable matter in military and security applications. As these technologies become more
advanced and versatile, they could potentially be used to develop weapons and other military
equipment that are more efficient and deadly than current systems. This raises concerns about
the potential for increased violence and conflict, as well as the need for effective international
regulations and oversight to prevent the proliferation of these technologies.
In order to address these and other ethical and social challenges associated with modular
robots and programmable matter, it will be necessary to develop a comprehensive and robust
framework of regulations and safeguards. This could include measures such as ethical guidelines
for the development and use of these technologies, as well as regulations to protect privacy and
security. In addition, it will be important to engage with a wide range of stakeholders, including
industry, academia, civil society, and government, in order to ensure that the development and
deployment of modular robots and programmable matter is ethical and responsible Eiben et al.
(2021).
In conclusion, the ethical and social challenges associated with modular robots and pro-
grammable matter are an important and complex issue that must be carefully considered
and addressed. By developing effective regulations and safeguards, and engaging with a wide
range of stakeholders, it will be possible to ensure that these technologies are used for the
benefit of society, rather than causing harm.
2.7. SIMULATION ENVIRONMENT 43
2.7/ Simulation Environment
VisibleSim is an open source behavioral simulator that runs distributed algorithms on lattice-
based modular robots Thalamy et al. (2021). It is designed for researchers with knowledge in
programming since it consists of a C++ framework. VisibleSim is a deterministic simulator
build to work in 2D and 3D lattices. Several types of robots can be simulated, and VisibleSim
is designed to accommodate the addition of new robotic architectures with ease. Simulations
in VisibleSim were compared to executions on real hardware, demonstrating VisibleSim’s high
precision for distributed algorithms, synchronization time, and mechanical resistance evalua-
tion.
In VisibleSim, written C++ code is executed on each module during the simulation. This set of
instruction is called a BlockCode. It is effectively the controller of the modules that describes
the behavior of the robot in response to all kinds of events. When a motion is completed, the
moving module sends an activation message to any new neighbors before beginning the next
weight move cycle. When all modules are activated, the simulation is complete.
VisibleSim has been able to simulate up to 32 million moving robots, which is the most ever
simulated. This establishes a new benchmark for visible sim, which can assist any researcher
in developing, testing, and debugging distributed algorithms for modular robots.
3
Leader Election
Contents
3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.1.1 Existing Leader election algorithms . . . . . . . . . . . . . . . . . . 46
3.2 Proposed algorithm and contribution . . . . . . . . . . . . . . . . . 48
3.2.1 Computing the weight parameter . . . . . . . . . . . . . . . . . . . 49
3.2.2 Recruitment phase . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.2.3 Tree value computation . . . . . . . . . . . . . . . . . . . . . . . . 51
3.2.4 Competition with other trees . . . . . . . . . . . . . . . . . . . . . 53
3.2.5 Dismantling trees and more recruitment . . . . . . . . . . . . . . . 55
3.2.6 Leader election phase . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.3 Termination with no Leader . . . . . . . . . . . . . . . . . . . . . . 58
3.4 Complexity analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
3.4.1 Theoretical analysis . . . . . . . . . . . . . . . . . . . . . . . . . . 60
3.4.2 Empirical analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
3.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
45
46 Leader Election
his chapter proposes a new algorithm for electing a leader that does not take into consid-
T eration any probability approach such as random identifiers or coin flipping. Furthermore,
the proposed algorithm reduces the probability of having a symmetric system since it uses
the connected interfaces’ number to generate identifiers. The results show that the proposed
algorithm, with a complexity of θ(n2 ), will end up with a leader with a high probability, and
was tested on Blinky Blocks in 2D and 3D systems.
3.1/ Introduction
In modular robots, many algorithms need a leader even though it is just to start a distributed
algorithm Naz et al. (2018a,b), the distributed leader election algorithm is therefore very
important. This algorithm can be simplified in a distributed consensus algorithm if there are
unique identifiers but it turns out to be much more difficult with their absence.
In the literature, leader election algorithms are often based on the probability of a coin flipping
which will, most of the time, lead to the repetition of the algorithm and an increased com-
plexity of the election Woods et al. (2013); Patitz (2012). In other approaches Woods et al.
(2013); Di Luna et al. (2019); Lu et al. (2014), the authors used an arbitrary identification
for the modules, and ran a comparison phase among them based on their previously defined
identification. In this case, some modules may end up with the same identifier and risk a
failure in the leader election. Furthermore, in this thesis the modules are considered to have a
joint internal clock as explained in details in definition 8. Therefore, the usage of randomness
is difficult to implement as all modules are homogeneous physically and logically.
This chapter proposes a new deterministic leader election algorithm with a complexity of
θ(n2 ). The same assumptions as in Gastineau et al. (2018) are taken, where modules have the
following properties: each module is anonymous, in other words, the modules do not have a
unique identifier or generates one of any kind. All modules are logically and physically identical,
and share the same clock. Each module has a set of ports that can be labeled by a consecutive
integer {0, 1, 2, ..., m}.
3.1.1/ Existing Leader election algorithms
Leader election is a fundamental problem in MRS. In this context, leader election is essential
and important for various and different applications such as shape formation Di Luna et al.
(2019); Wei et al. (2010); Pavliuk et al. (2020), self-repair Ikizoglu et al. (2020); ZHANG et al.
(2008), self-assembly algorithms Tucci et al. (2018); Thalamy et al. (2019a), decision making
Andreev et al. (2019); Yu et al. (2010), etc. It is important to have a leader because it helps
to coordinate the activities of the various components in the system, so that they can work
together to achieve a common goal. The leader is responsible for making decisions, assigning
3.1. INTRODUCTION 47
tasks, and ensuring that the different parts of the system are working together efficiently. The
leader helps to ensure that the system remains stable, despite any failures or changes in the
network. Additionally, having a leader helps to prevent the system from becoming bogged
down in an endless cycle of conflicting decisions and conflicting commands. Leader election
is a fairly old problem in distributed systems, it consists in electing a unique leader from a
fixed set of nodes Jiang et al. (2020); Stoller (2000). Indeed, several algorithms have been
proposed in the literature to solve this problem. However, in the context of MRS, multiple
challenges must be taken into account to elect a leader. The first one is the homogeneity
or uniformity of the system. All particles are considered to follow the same program. They
are anonymous and indistinguishable and do not share any kind of coordinate or positioning
system. A deterministic method is of paramount importance since all modules, used in this
thesis, are identical, therefore, they will be using the same pseudo random function and the
same seed, this will end up generating the same number for the modules each time they pick
a random number. The second challenge is the low energetic and computation resources of
the particles. Therefore, the solution must be non-complex and suitable for the robots used in
this thesis.
Although the importance of leader election in modular robots systems, it has received little
attention until now. For instance, the works presented in Patitz (2012); Woods et al. (2013);
Lu et al. (2014) are fully theoretical based on graph theory, probability and random number
generation approaches. After implementing these solutions, the simulation may end up with
no leader.
In Gastineau et al. (2018), the authors introduced a new leader election algorithm. This
algorithm is very easy to implement. It works on certain kinds of topologies: a square or king
graph representations. To be able to use this method, the graph should not have any holes in
it. In other words, there is only an outer boundary and no inner boundaries.
In Di Luna et al. (2019), the authors introduced an approach to the leader election algorithm
and they precisely mentioned that the algorithm does not work on systems with holes. The
system is divided into multiple spanning trees. Each root of those trees is a candidate. In order
to elect a leader, the candidates scan their respective trees of the spanning forest. In each
step, the modules of each tree send a constant length code to their parent, describing their
neighborhood. The message is then forwarded all the way to the candidate leader at the root
of the tree. Once all candidate leaders have obtained a code from a particle in their respective
tree, they send each other these codes and compare them. If the codes are not all equal, the
candidates are able to elect a unique leader. Otherwise, the election attempt fails, and each
candidate leader asks one of its children for another neighborhood code.
In order to break the symmetric system, the solution proposed in Emek et al. (2019) is based
on physically moving the modules when confronted wish make the system consume more time
and energy. This algorithm does not use random number generation, does not require the
48 Leader Election
modules to have a common chirality, does not take into consideration if the system has holes
in it or not. At the end of its execution, only one leader will be elected. The execution time
complexity of this algorithm is O(Ln2 ) where L is the size of the outer boundary at the initial
state of the algorithm and n is the number of particles in the system. However, this algorithm
is complex and not suitable for limited resources modular robots.
Despite all the proposed solutions by the different authors, the leader election algorithm has
always a complexity of O(n) except for the algorithm of Emak et al. ? that has a complexity
of O(Ln2 ). A lot of challenges will be faced when implementing those solutions.
Therefore, this chapter will be proposing an algorithm that does not take any probability
approach such as random identifiers or coin flipping. The proposed algorithm will end up with
a leader with high probability, and was tested on Blinky Blocks in VisibleSim simulator. In the
proposed approach, the port numbering and orientation as well as the summation of an integer
generated will be used in order to break the symmetry of the system. A symmetric system in
this approach is defined in 3.The probability of having a symmetric graph is considered to be
negligible specially with high number of modules.
In summary, Table 3.1 compares six algorithms among what was studied in the literature with
the algorithm proposed in this chapter.
Bazzi et al. (2018) Daymude et al. (2017) Derakhshandeh (2017) Di Luna et al. (2019) Gastineau et al. (2018) ? Proposed algorithm
Multiple Leaders Yes No No Yes No No No
Random Numbers No Yes Yes Yes Yes No No
Holes Yes Yes Yes No No Yes Yes
Same Chirality Yes Yes Yes No Yes No No
Implemented No No No No No No Yes
Complexity NA O(L) O(Lmax) O(n) O(2(r + mtree + 1)) O(Ln2 ) O(n2 )
Table 3.1: Comparison of all leader election algorithms
The remainder of the chapter is organized as follows. Section 3.2 presents and explains the
proposed algorithm. The termination with no leader will be discussed in Section 3.3. In
section 3.4, the results are shown, analyzed and the complexity is studied. Finally, Section 3.5
presents the conclusion and perspectives.
3.2/ Proposed algorithm and contribution
This section will be describing the proposed solution in details. The algorithm is based on six
phases. First, each module generates locally an integer, called weight, based on the numbering
of their connected interfaces. After that, spanning trees will be created using a recruitment
method, then the values of the recruited modules will be calculated, the generated spanning
tree will compete and the loosing trees are dismantled, this step is repeated until one tree
remains. And finally the leader is elected.
3.2. PROPOSED ALGORITHM AND CONTRIBUTION 49
3.2.1/ Computing the weight parameter
Considering that each robot is connected to up to d neighbors, (d is the degree of the associated
graph), and defining Ci the state of the ith connector (setting Ci = 1 if connected and Ci = 0
elsewise) the weight is encoding by concatenating the d bits. Then using the connected
interfaces and its orientation, each module will be generating its weight w as follows:
d−1
(3.1)
∑︂
w= 2Ci
i=0
Where Ci is the state of the connector i (1 if connected 0 otherwise), d is the degree of the
graph (the number of connectors).
When an interface is connected, the number of that interface will be referred to as 1 and if
not, it will be referred to as 0. In the case of Blinky Blocks in 2D which have 4 neighbors,
each block will end up with a binary number of four bits. Then, each module enumerates
its interfaces with the same manner. The next step is to create the integer from the binary
generated.
Some examples of the number generation are presented in Figure 3.1 with different kinds of
robots. Both position and orientation of the module affect its weight. For example, if a
module in a square lattice has the interfaces 0 and 3 connected, the respective binary number
is (1001)bin which gives (9)dec in decimal.
By the end of this step all the modules will have generated an integer as previously described.
This weight will be used in the third phase of the algorithm to be able to compute the tree value.
This technique is based on the interfaces’ connections of the modules. In the algorithms below,
the interfaces status are used as shown in Table 5.1. InterfaceStatus is an array of type integer
that contains the status of the interfaces. Table 5.1 shows the different status the interfaces
can take during the execution of the algorithm. At the end of this appendix, a complete and
detailed diagram of the proposed leader election process is presented (cf. Figure 3.14).
Status Definition
0 interface not connected
1 interface connected
2 interface connected to a neighbor that is not in its tree
3 interface connected to its parent
4 this interface received a sum message
5 this interface sent a potential leader message
Table 3.2: Interface status
Algorithm 1 presents the integer number generation based on the connected interfaces and the
orientation. The integer generated is referred to as BChoice, NumbOfInterfaces is the number
of interface each module has. The number of interfaces in this scenario is four for the 2D
50 Leader Election
simulation and 6 for the 3D simulation.

3 3
0001 0 0110 0 110001 011100
2 1 2
6 49 28
1 1
2
0101 3 000110 111011 001110
1 5 6 59 14
0
0 5
4
0001 1 110000 0
3
1 3 48
2 2 1
Figure 3.1: Examples of weight generation based on the interfaces connections for two different
2D lattices (cubic on the left similar to Blinky blocks that are the modules used in this thesis,
and hexagonal on the right as another example on how to generate weight based on interface
connection, however this model was not used in this thesis). Grey triangles mark #0 connectors,
others are placed clockwise.
3.2.2/ Recruitment phase
In this section, prospective leaders will start competing by recruiting modules to create their
spanning tree. In this scenario, prospective leaders are chosen as follow: if the module has only
one connection, it directly becomes a prospective leader. If a module has two connections, it
will wait for a T 2 time and after that time if it was not recruited it will become a prospective
leader and start the recruitment process. Likewise, modules with 3 connections will wait for T 3
time and so on. The delay T i , where i is the number of connected interfaces, can be fixed by
the user before the execution of the algorithm. It can be computed in function of the diameter
of the network and the speed of the message propagation.
When an available module receives a recruitment message, it marks the interface from where
the message was received as parent interface, changes the module flag to recruited, informs
its parent that the recruitment was successful and starts recruiting its remaining connected
modules. This process will continue until all modules in the system are recruited. When a
module has no neighbor to recruit or all its neighbors are already recruited, it will be depicted
as a leaf of the tree since no more children can be recruited. After that, each spanning tree
will have two properties, the total number of modules recruited in the tree and the sum of the
weights (calculated in phase 1) of the modules in the same tree. Algorithms 17 and 3 provide
more details what happens when a module receives a recruit message and when an already
recruited module receives a recruit message respectively.
Algorithm 1: Choice generation and interface set up

Input: NumbOfInterfaces
Output: BChoice, interfaceStatus
Data: Testing Connected Interfaces
1 for ( i = 0 to NumbOfInterfaces ) {
2 if getInterface[i] is connected then
3 interfaceStatus[i] = 1
4 totalConnectedInt++
5 bchoice = bchoice + 2i
6 else if getInterface[i] is NOT connected then
7 interfaceStatus[i] = 0
An illustration example of the recruitment phase is presented in Figure 3.2. In this example,
two prospective leaders will start recruiting modules until no more modules are available.
1 14 10 7 10 1 1 14 10 7 10 1 1 14 10 7 10 1
5 10 5 10 5 10
6 5 6 6 5 6 6 5 6
1 2 3
1 14 10 7 10 1 1 14 10 7 10 1 1 Module with weight
5 10 5 10 1 Root of the green graph
6 5 6 6 5 6 1 Leaf of the blue graph
4 5
Figure 3.2: 5 steps of the recruitment process: Roots start recruiting modules until no more
modules are available.
3.2.3/ Tree value computation
Once a module appoints itself as leaf, it sends its weight to its parent. And every time a parent
receives such a value, it will increment the counter that counts the number of modules, and it
will flag the interface from where the value was received as value sent. Once all the interfaces
that are connected to its children sent their values, the module computes the sum of all the
received values and sends it to its parent. This process will keep on executing until it reaches
the tree root. In like manner, the root itself will process the message as previously described
and, as a result, the final value of that tree and the total number of modules are calculated.
Forthwith, the root will then broadcast the tree value and the number of modules in its tree to
all its children. As soon as a module receives this type of message, it will save those variables
in its local memory and sets its ”ready to compete” flag to true. Identically, this module will
forward the same message to its children, that will treat this message in the same fashion,
until it reaches the leaves. As previously described, the competition among the trees is done
52 Leader Election
Algorithm 2: Received recruit message

1 if received message is a recruit message then
2 if Not recruited and not root then
3 recruited = true
4 parent = sender
5 interfaceStatus[sender] = 3
6 if all interfaces != 1 then
7 if i am leaf then
8 total = choice
9 Send sum Msg to parent
10 else
11 Send recruit Msg through the connected interfaces except parent interface
12 else
13 Reply back with already recruited
through the connected leaves or modules. Therefore, the tree root should send the total sum
of the tree to all its children in order to compete with other trees. Algorithm 4 shows how the
sum message is being handled by the modules and Algorithm 5, explains the steps done by the
modules to broadcast the sum of the tree to all its children.
Figure 3.3 shows an illustrative example of this phase. Starting from the leaf, each module
sends its value to its parent. The parent adds it up to its own and - after having received all
values from its children - sends it backward until the message reaches the root of the tree.
Once the sum reaches the root, it will be added to the root’s value and then the root broadcast
it to all the modules in the same tree.
40 10 23 33
41 34
1 14 10 7 10 1
41 41 34 34
41 16 34 16
23 Message sending the sum of the weights
5 10 of the subtree.
41 11 34 6 Message flooding the value of the group.

41
5
6 5 6 34
Value of the group computed by the
root node.
41
Figure 3.3: Group value computation: Starting from the leaf of each group, each leaf sends
its weight to its parent. The parent adds the received value with its weight and then send the
result backward until it reaches the root of the tree. Once the sum reaches the root, it will be
added to the root’s weight to define the group value. This group value is then broadcast to
all the modules of the tree.
Algorithm 3: Received recruited message

1 if received message is a recruited message then
4 i am leaf = true
5 send sum message to parent
6 if I don’t have neighbors from another tree then
7 send potential leader message to parent
Algorithm 4: Received sum message

1 if received message is a sum message then
3 tmpTotal += rcvdMsg
5 tmpTotal += BChoice
6 totalNode + 1
7 if i am root then
8 treeValue = tmpTotal
9 Send update tree value Msg to all interfaces with status 1 and 4
10 else
11 Send Sum Msg to parent
3.2.4/ Competition with other trees
In this section, all the modules are ready to compete. To put it in other words, all modules
received the total number of particles in their tree and the sum of all its integers, and in
addition, they have their ”ready to compete” flag set to true. Modules that have neighbors
recruited to a different tree, send them a competing message containing the sum of the tree
and the number of modules. The receiving party then compares those variables with the one
stored in their memory. The module with the higher sum wins. If both trees have the same
value, then the tree with more modules is the winner. There are rare and negligible cases
where both sum and total number of modules are the same for the competing trees, this is
called symmetry and is discussed in details in section 3.3 of this chapter. Algorithms 6, 7 and
8 show in more details the competition phase.
54 Leader Election
Algorithm 5: Updating tree value

1 if received message is an update tree value message then
2 MyTreeValue = rcvdMsg
3 readyToCompete = true
4 send update tree value Msg through interfaces with status 1 and 4
5 Send choice Msg through interface with status 2 // to start the competition
with other trees
Algorithm 6: Receiving choice message

1 if received message is a choice message then
2 if ready to compete then
3 if Msg < MyTreeValue then
4 I am leaf = false
5 Send lost message to sender
6 else if Msg > MyTreeValue then
7 Set all interfaces with status 3 and 4 to 1
8 Send win message to sender
9 Send dismantle message to parent
Win Msg
Received
Yes
Msg = 1
Send Reset
Sum Msg to
parent
No
Lost Msg
ReceivedMsg=0
Do nothing No and
I am not leaf
iAmLeaf=false
Dismantle=true
Yes
Set all
interfaces
Set all withs status 3
interfaces
with and 4 to 1
status 2
to 1
Send dismantle Msg to parent

Re-initiate recruitment
(a) Activity Diagram when re- (b) Activity Diagram when re-
ceiving a win message ceiving a lost message
Figure 3.4: Activity Diagram when receiving win/lost messages

Algorithm 7: Receiving win message

1 if received message is a win message then
2 if recvdMsg = 1 then
3 Send Reset Sum Msg to parent
4 else
5 if ReceivedMsg=0 and I am not leaf then
6 Set all interfaces with status 2 to 1
7 Re-initiate recruitment
Algorithm 8: Receiving lost message

1 if received message is a lost message then
2 iAmLeaf=false
3 Dismantle=true
4 Set all interfaces withs status 3 and 4 to 1
5 Send dismantle Msg to parent
3.2.5/ Dismantling trees and more recruitment
As a result of the previous competitions, loosing trees will become dismantled. In this scenario,
dismantle is defined as breaking into pieces. This means that the modules that were the children
of the loosing tree will no longer be related to that tree and they will be restored to their state
before the recruitment. The process operates as follow: the leaf that received the loosing
message, will send that message back to the tree root. In his turn, the root broadcasts to all
its children the dismantle message. Consequently, the particles receiving the dismantle message
set the recruited flag to ”false”, the interfaces that are flagged as parent and children are no
longer flagged. Furthermore, the variables containing the value of the tree and the number
of modules are set back to zero. Once the dismantle process reaches the leaf of the loosing
tree, it will send a message to the winning tree that the dismantle is finished. As a result, the
winning tree will re-initiate the recruitment and start recruiting the dismantled modules in the
same manner. Algorithm 9 explains the dismantling process in details and Algorithm 10 shows
how to reset the sum of the tree.
56 Leader Election
Algorithm 9: Dismantling tree

1 if received message is a dismantle message then
2 if Node Not reset then
3 if Not root and rcvdmsg = 0 and dismantle not sent then
4 Send dismantle Msg to parent;
5 else
6 if I am root then
7 iAmRoot=false
8 nodeReset=true
9 myParent=NULL
10 recruited=false
11 Send dismantle Msg with value 1 through interface with status 1 and 4
12 else
13 if rcvdMsg != 1 then
14 NodeReset=true
15 Parent=NULL
16 Recruited=false
17 Send dismantle Msg with value 1 through interface with status
different than 0 and 2 except the sender interface
18 interfaceStatus=1
19 iAmLeaf=false when interfaceStatus=2
20 Send win Msg with value 0 through interfaces with status 2
41>34 Blue wins

you
41 41 41 34 34 34 41 41 41 loose 34 34 34
41 34 41 34
you
41 41 34 41 41 win
34
1 2
41 41 41 34 34 34 1 14 10 7 10 1
41 34 5 10
Messages
reset
41 41 34 dismantle 5 6 5
3 4
Figure 3.5: 4 steps of the dismantling recruitment: First step presents the initial state, step
2 shows the competition between the two groups, the blue group win on the green group,
then each leaf of the two groups produces reset and dismantle messages. Step 3 shows the
broadcasting of reset and dismantle messages. At the end, step 4, their is only one group and
nodes are reset.
Figure 3.5 presents an example of the dismantling recruitment. In this example the loosing
modules send a dismantle message to their parent until it reaches the root of the loosing tree.
Algorithm 10: Reseting the sum of the tree

1 if received message is a reset sum message then
2 if iAmNotRoot and rcvdMsg = 0 and resetSum not sent then
3 Send reset sum message with value 0 to parent
4 else
5 if iAmRoot and rcvdMsg = 0 and resetSum not sent then
6 ResetSumSent=true
7 tmpTotal=0
8 MyTreeValue=0
9 ReadyToCompete=false
10 Set all interfaces with status 4 to 1
11 Send reset sum Msg with value 1 through interfaces with status 4 or 1
12 else
13 if rcvdMsg=1 then
14 ResetSumSent=true
15 tmpTotal=0
16 MyTreeValue=0
17 ReadyToCompete=false
18 Set all interfaces with status 0 or 2 to 1
19 Send reset sum Msg with value 1 through interfaces with status 0 and 2
except the sender’s interface
In the mean time, the winning tree sends a message to its parent until it reaches the root to
reset the value of the tree. Furthermore, the winning modules start recruiting the loosing tree.
3.2.6/ Leader election phase
As long as the system contains multiple trees, the competition will go on and recruitment will
be re-initiated until one tree remains. This occurs when all the modules of the tree are not
connected to any other tree. The root of this tree will then be elected as leader 11.
After the election, the leader will change its leader flag and leader found flag to true, broadcast
a leader found message to all its neighbors, and restore to its initial state before the beginning
of the algorithm except for the leader flag and the leader found flag that should remain set to
true. Correspondingly, every module that receives the leader found message, will restore to its
initial state and then sets the leader found flag to true 12.
Figure 3.6 presents an example of the last phase of the leader election approach. Once a
module can not recruit or compete further, it will send a ”potential leader” message to its
parent. Each parent that receives this type of message, will wait until all its children send
him the same message then send it backward to its parent. So far until the message reaches
the root. If this message reaches the root, the root becomes the leader and broadcasts to all
modules in the system that it is the leader.
58 Leader Election
Algorithm 11: Potential leader message

1 if received message is a potential leader message then
2 ReceivingInterface = 5
3 if All interfaces =5 then
4 if i am root then
5 iAmLeader=true
6 LeaderFound=true
7 Send Leader found Msg to all neighbors
8 else
9 Send potential leader Msg to parent
Algorithm 12: Leader found message

1 if received message is a leader found message then
2 leaderFound = true
3 if I am not a leaf then
4 Send Leader found Msg to all neighbors
1 14 10 7 10 1 1 14 10 7 10 1 1 14 10 7 10 1
5 10 5 10 5 10
5 6 5 5 6 5 5 6 5
1 2 3
Nodes of the initial tree,
1 initial PL senders
1 14 10 7 10 1 1 14 10 7 10 1 Wait for PL from all its
1 children
5 10 5 10 PL message
Leader found message
5 6 5 5 6 5 1 Elected leader
4 5
Figure 3.6: Leader election: 1) Once a module can not recruit or compete further, it sends a
Potential Leader message (PL) to its parent. 2)& 3) Each parent that receives PL message
waits for all its children PL message and then sends it backward to its parent. 4) So far until
the message reaches the root, which becomes the leader and broadcast (5) to all modules in
the system that the leader is elected.
3.3/ Termination with no Leader
This section will be explaining the conflicts that might occur during the leader election al-
gorithm. As mentioned previously in Section 3.2.4, a symmetry occurs when two, or more,
competing trees end up with the same total value and the same number of modules. This
might happen at the end of the algorithm when only two trees are remaining.
When the system has three trees where two are having the same values and a third one with a
3.3. TERMINATION WITH NO LEADER 59
different value, this is not called a symmetry because the third tree will be loosing or winning
against one of the two trees. This will result in having a bigger tree that will win against the
remaining one. Figure 3.7 shows an example of two cases. Figure 6.21c presents a symmetry
scenario while in Figure 6.21d there is no symmetry. The aim of this section is to discuss
the probability of symmetry occurrence and show that it is very low while following the above
proposed for leader election.
(a) Two trees with exactly the same number of (b) Three spanning trees. The green and blue trees
modules and the same total value. are identical.
Figure 3.7: Comparison of two cases, a) and b) has the same blue and green trees but b) has
yellow modules in addition. In the case b), yellow tree will dramatically change the results.
The yellow tree will be loosing against the blue tree, and it will be then merged into one tree.
So in this case having two identical trees is not considered as a conflict.
As discussed, the proposed algorithm may terminate without electing a leader. It happens
when at the end of a recruiting phase, all trees have both the same number of nodes and the
same weight. It would be very hard to precisely compute the probability of being in such a
situation. However it seems to occur very unlikely: rotating any module on a border (with at
least one open connection) will break the symmetry and there is no selected orientation of the
modules. The ”no leader” situation was never observed in any of the experiments executed.
Nevertheless, it may be possible to improve the algorithm to fix this problem with a high
probability in the following way. When a blocking situation with no leader is detected (that
may be done using a time counter), a new stage starts. From each leaf a message is sent to
the root with all the information in order to provide to the root the whole structure of the
tree. Then, this complete structure is broadcast to the leaves.
Now, a new challenging procedure can start by tree comparisons (rather than just weights
and numbers of nodes) using any tree order (for instance a lexicographic order). With this
new algorithm, it may also happen that there is no leader election: when all the involved
trees are exactly the same. Considering that a shape is a connected graph on the grid with
60 Leader Election
an orientation of each node, it is possible to estimate the probability of non termination on

the uniform distribution over equivalent shapes (two shapes are equivalent if there exists a
combination of rotation, translation, reflection or glide reflection transforming one shape to
the other one).
Since for large n rotations are very unlikely, it might be estimated that there are about
n
sn = c (4λ)
n different shapes Jensen et al. (2000), with c close to 3 and λ close to 4.
Now, under these hypotheses, the number of shapes with n nodes that can be split into k
k ) 4 : s k is the number of ways to chose the tree
exactly equal trees is less or equal to s nk ( 4n k k n
and ( 4n
k ) an upper bound on how to put the k copies of this tree together and the 4 is for
k k
the possible orientations for each tree.

sn/k
It results that the probability a shape can be divided into k equal trees is bounded by sn ≤
knk 4k
n k−1
, which is exponentially small. Since k may vary at most from 2 to n/2, one can
kk (4λ) k
estimate that the probability that this new algorithm doesn’t find any leader is exponentially
small.
The algorithm proposed in the previous paragraph has not been implemented. It is important
to point out that if a blocking situation is critical, the algorithm can be modified in order to
works with an estimated high probability.
3.4/ Complexity analysis
The purpose of this section is to explore the complexity analysis of the algorithm developed in
the previous section. This section will first explore the theoretical complexity analysis of the
algorithm. It will then go on to explore the empirical study of the complexity of the algorithm.
3.4.1/ Theoretical analysis
The time complexity of an algorithm is analyzed when at least one module starts executing
the algorithm. The time complexity depends on T1 , T2 , . . . , Tn where T is the execution time
in each module and n the total number of modules.
The analysis is based on counting elementary operations: sending a message, checking an

interface, comparing two values, computing a sum, etc. Those operations are assumed to take
linear time O(1).
3.4.1.1/ Upper Bound
Proposition 1 . In the worst case scenario, the leadership election algorithm will work in time
Θ(n2 ) and Θ(n2 ) messages will be sent. The total number of elementary operations is also
3.4. COMPLEXITY ANALYSIS 61
Θ(n2 ).
As previously discussed, the algorithm will be executing in multiple steps. Below is an in-depth
explanation of each step, with relation to its complexity:
1. Integer number generation: This Step, done in parallel by each module, is done in time
O(1) and requires a total of O(n) operations. No messages are sent in this step, hence
the message complexity is null.
2. Recruitment phase: Each module sends O(1) messages: there is a total of O(n) messages
sent. Each module performs O(1) operations and the broadcast ends in time O(n).
3. Tree value computation: As in the previous step, the tree value computation is performed
in time O(n), each module performing O(1) operations. There are also O(n) sent
messages.
4. Competition and dismantling trees: Similarly to steps 2 and 3, this step is performed in
O(n) time. Each module performs O(1) operations. Furthermore, O(n) messages are
sent.
5. Leader election phase. This phase has an identical complexity as the previous phases.
Therefore, this phase is done in O(n) since each module is performing an O(1) operation.
Also this phase has a message complexity of O(n) since each leaf report back to its parent,
until the message reaches the root.
Steps two through four may be repeating. But at each stage, the number of trees is decreasing.
Therefore, since there are at most n trees, these steps can be repeated at most n times.
In conclusion, the algorithms works in time O(n2 ) and O(n2 ) messages are being sent. More-
over the total number of performed elementary operations is also O(n2 ).
3.4.1.2/ Lower Bound
For the lower bound analysis, a two-dimensional configuration is used, but the proof is easily
generalized for other contexts. Considering that n = 3m, each module is identified by an
integer from 0 to 3m − 1.
Modules are placed on the grid by blocks of 3 as follows (note that all blocks are similar except
the one on the left and the one on the right; see Figure 3.8 for an illustration):
62 Leader Election
1 1 1 1
2 0 4 2 3 4 2 6 4 2 9 4
3 3 3 3
4 2 2 3
1 3 4 2 2 3 4 1 3 5 1 3 7 1 3 8 1 4 10 2 1 11
Figure 3.8: Example of initial configuration with m = 4.
• Modules of the from 3i with 0 ≤ i ≤ n − 1, are placed respectively on positions (2i, 1).
They all have their interface 1 connected.
• Modules of the form 3i + 1, with 0 ≤ i ≤ n − 1, are placed respectively on positions

(2i, 0). Module 1 has interfaces 3 and 4 connected. Module 3m − 2 has interfaces 2, 3
and 4 connected. All others (for 1 ≤ i ≤ n − 2) have interfaces 1, 2, and 3 connected.
• Modules of the form 3i + 2, with 0 ≤ i ≤ n − 1 are placed respectively on positions

(2i + 1, 0). Module 2 have interfaces 2 and 4 connected. Modules 3m − 1 have interface
1 connected. All others (for 1 ≤ i ≤ n − 2) have interfaces 1, 2, and 3 connected.
It may occur that the recruitment phase ends up with m − 1 three modules trees. Each tree
will have the modules {3i, 3i + 1, 3i + 2} where 0 ≤ i ≤ m. Starting from the left side, the
tree {0, 1, 2} has a weight of 23. On the right side of the graph, the system might end up
with {9, 10} and {11}, or {9} and {10, 11}. In either case, the tree containing two modules
will have a weight of 15. The middle of the graph contains the trees with a weight equals to
13. The dismantling process will start from both end of the graph at the same time. In other
terms, the tree {0, 1, 2} will take over {3, 4, 5} and at the same time the tree {9, 10} will take
over {11} and {6, 7, 8}. The system now has two trees only. Tree A containing {0, 1, 2, 3, 4, 5}
and tree B containing {6, 7, 8, 9, 10, 11}. A has a weight of 36 and tree B has a weight of
29. Therefore, A takes over B. In this unlikely context, steps 2 to 4 are repeated m−1
2 times
(for large m). After the k-th iterations, the depth of the dominating tree is 2k and, therefore,
Θ(k) messages and a time in Θ(k) are required, proving the lower bound.
3.4.2/ Empirical analysis
To study the complexity of the contributed algorithm, The method presented in Schneider
et al. (2011) is followed. The authors defined the efficiency of a distributed algorithm with at
least one out of three conventional distributed complexity measures:
• Time complexity (number of rounds for synchronous algorithms)
• Communication or bit complexity (overall range of bits transmitted)

• Message complexity (total number of messages transmitted).
Depending on the scenario, one or another measure might be more relevant. The bit complexity
will be dropped in this analysis, since the size of the messages sent in programmable matter is
considered to be negligible.
(a) Shape 1 (b) Shape 2 (c) Shape 3
Figure 3.9: The 3 configurations of Blinky Blocks used in the simulation
The modules used in the simulations are Blinky Blocks in 2D but the algorithm should work
on all types of modules. At the initial state, all modules are identical. In 2D, the Blinky
Blocks has 4 connections numbered from 1 to 4. Each module is aware of the interfaces
that are connected. A series of simulations were executed on VisibleSim show a running of
the algorithm on a simple configuration recorded from VisibleSim simulator in 3D. In those
simulations, different modular robots system shapes are considered while varying the number
of the modules in the system as shown in Figure 3.9. The shapes were increased in size after
each simulation to be able to analyze the complexity based on the total number of connected
modules. Furthermore, the following subsection will discuss the time and message complexity of
the proposed algorithm while comparing it with the existing deterministic algorithm presented
by Emek et al in ? since it is the closest to the proposed algorithm.
3.4.2.1/ Time complexity analysis
In this section the time complexity of the algorithm is studied. In other words, the execution
time needed by the algorithm to find one leader. Three different shapes are considered (random
(shape1), Square (shape2) and line (shape3)) as shown in Figure 3.9 and it is compared to the
work presented in ?. In order to confirm the linearity of the results, a regression line is drawn
in each graph using the least square regression method based on the average value gathered
during the simulation.
64 Leader Election
10 5
2.5
Shape 1
Shape 2
Shape 3
Mean
2 Regression line
Elapsed time in s
1.5
0.5
0
0 200 400 600 800 1000 1200 1400
Number of modules
Figure 3.10: Execution time Vs. number of modules
Figure 3.10 shows the obtained results of the time needed to finish the execution versus the
number of modules presented in the system. First, this figure shows that for the same number
of modules the execution time remains almost the same while varying the shape of the modular
robot. Furthermore as expected, it is noticeable that the execution time increases in a linear
manner with the number of modules. The coefficient of determination of the regression line
in Figure 3.10 has a value of 97.5%. In another word, the regression line drawn is considered
to be 97.5% accurate. Therefore the time complexity is considered to be linear with high
accuracy.
To compare the proposed work to the literature, the algorithm presented in ? was implemented
under the same conditions as the proposed algorithm. The results of the execution time are
shown in Figure 3.11. It is clearly shown that the proposed algorithm outperforms the approach
presented in ? in terms of execution time as well as in terms of event processing and energy
consumption since in ? the modules should move physically in order to find one leader.
5
10
ELECTOR
15 EMEK et al
Elapsed time in s
10
0
0 200 400 600 800 1000 1200 1400
Number of modules
Figure 3.11: Time complexity comparison between the proposed algorithm and ?
3.4.2.2/ Message complexity analysis
In this section the message complexity of the proposed algorithm is discussed (i.e. the number
of exchanged messages between modules before electing one leader). Figure 3.12 shows the
number of messages exchanged to finish the execution of the algorithm on the simulator versus
the number of modules presented in the system. Similarly to the time complexity analysis, it
is clear that for the same number of modules the number of the exchanged messages remains
almost the same while varying the shape of the modular robot. Furthermore, the number
of the exchanged messages increases linearly with the number of modules. The coefficient
of determination of the graph in Figure 3.12 has a value of 97.8%. In another word, the
regression line drawn is considered to be 97.8% accurate. Therefore the message complexity
of the proposed algorithm is considered linear as well with high accuracy.
12000
Shape 1
Shape 2
Shape 3
Mean
10000 Regression line
Number of messages exchanged
8000
6000
4000
2000
0
0 200 400 600 800 1000 1200 1400
Number of modules
Figure 3.12: Number of messages exchanged Vs. the number of modules

66 Leader Election
Figure 3.13 shows a comparison of the proposed approach and the one proposed in ? in
terms of message complexity. Once again, it is clearly noticeable that the proposed algorithm
outperforms the approach presented in ? and needs far fewer messages exchanged between
modules in order to elect a leader.
10 5
18
ELECTOR
Emek et al
16
14
Number of messages exchanged
12
10
0
0 200 400 600 800 1000 1200 1400
Number of modules
Figure 3.13: Message complexity comparison between the proposed algorithm and ?
3.5/ Conclusion
This chapter presented a fast, reliable and robust leader election algorithm for modular robots.
The proposed algorithm ends up with a leader elected in high probability. It does not use
random number generation. It works on 2D and 3D systems and has a complexity of O(n2 )
in the worst case. Both theoretical and empirical analysis were presented in this chapter. The
Theoretical analysis showed that the algorithm has a squared complexity, whereas the empirical
analysis showed that the complexity is linear. In the future, it is important to execute more
simulations with different configurations and using different types of MRS to end-up with a
more accurate empirical analysis.
The proposed algorithm is a six phases-based algorithm. First, the modules generate integers
based on the number of connected interfaces. After that, spanning trees are created using a
recruitment method. The generated spanning trees compete and the loosing trees are disman-
tled until one tree remains, and a leader is elected. The simulation results show the efficiency
of the proposed algorithm.
3.5. CONCLUSION 67
Figure 3.14: Detailed diagram of the leader election process

4
Reconfiguration using virtual
forces
Contents
4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
4.2 Literature Review . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
4.3 Assumptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
4.4 Proposed Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.4.1 Distributed Virtual Force Algorithm (VFA) . . . . . . . . . . . . . . 75
4.5 Simulation Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
4.6 Conclusions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
69
70 Reconfiguration using virtual forces
his chapter tackles the self-reconfiguration problem by presenting a deterministic planning

T algorithm that can decide which positions can be filled over multiple iterations using
virtual forces. The proposed algorithm implements the Hungarian method to optimize the
planning by minimizing the total number of movements of the robots and preventing positions
from being blocked. Each module embeds the same algorithm and coordinates with the others
using neighbor-to-neighbor communications. Simulation results are conducted to show the
effectiveness of the proposed approach.
4.1/ Introduction
One of the foremost interesting capabilities of modular robots, is the capacity of each module
to move towards diverse positions, changing the whole shape and morphology of the grouped
modules to achieve different tasks and to adapt to terrain variations. According to Tucci et al.
(2018), this can be achieved either using self-reconfiguration or self-assembly which are hard
problems for the following three reasons. First, working with a large number of computational
units generates a huge number of possible unique configurations, (c.w)n where n is the number
of modules, c the number of possible connections per module and w the ways of connecting the
modules Park et al. (2008). Second, the modules can move simultaneously, so the branching
factor of the tree describing the configurations is O(mk) with m being the number of possible
movements and k the number of modules free to move. Finally, the exploration space of
a reconfiguration between two situations is exponential in n which prevents from finding a
complete optimal planning.
In this chapter, a new self-reconfiguration algorithm for modular robots based on virtual forces
is proposed. The main objective is to optimize the shape formation by minimizing the number
of movements of the modules. The Virtual Force Algorithm, denoted as VFA for the remainder
of the chapter, was introduced by Zou et al. (2003) to properly place a randomly distributed set
of sensors. Once the effective sensors positions are identified, a one time movement with energy
consideration incorporated is carried out, i.e., the sensors are redeployed to these positions.
This work was inspired by the VFA to identify the attractiveness of empty positions for the
free modules.
The remainder of this chapter will be as follow: Section 4.2 presents the literature review, a
brief review of prior research on topics related to self-assembly, self-reconfiguration and virtual
forces approach in the robotics world. Section 4.3 presents the particularities of the modular
robot used and the details about the problem we aim to address. Section 4.4 describes the
proposed algorithm. Section 4.5 presents the simulation results based on the proposed approach
and an elaboration on its performance. Section 4.6 draws the conclusion and outline directions
for future works.
4.2. LITERATURE REVIEW 71
4.2/ Literature Review
The Virtual Force Algorithm, denoted as VFA for the remainder of the chapter, was first
introduced by Zou et al. (2003) to properly place a randomly distributed set of sensors. The
study, drawing inspiration from the VFA, determines the allure of unoccupied positions for the
unencumbered modules by determining the effective positions of the sensors. Subsequently,
a single adjustment with energy consumption taken into account is executed, relocating the
sensors to these identified effective positions..
A self-reconfiguration algorithm is composed of two phases: an assembly planning phase and

a movement phase. In ?, the authors propose a distributed algorithm for building a shape
by defining on the fly the assembly planning. The advantage of this method is that it does
not require any pre-calculation which allows a total adaptability to the situation and a better
resistance to errors. The difficulty in this case is to detect and deal with blocking situations
so as not to position a robot in a location that will then block the others. They propose a
distributed algorithm based on long-distance communication between robots, using the point-
to-point communication network, in order to manage these situations. The algorithm works
even in configurations with multiple holes that are the most complicated to manage.
The authors in Seo et al. (2013) proposed an assembly planning algorithm for constructing
planar structures out of rectangular modular robots that can dock to each other to form a
brick wall pattern. The assembly plan incorporates reachability and collision constraints and
supports distributed assembly so that multiple robots can be docked to a growing structure
without centralized coordination.
In their paper, Naz et al. (2016a), the authors introduced a parallel, asynchronous and fully
decentralized distributed algorithm to self-reconfigure robots in 2D vertical lattice from an
initial configuration to a goal structure. Their algorithm avoids collisions by having a gap of
one empty cell between robots that are in transit using communications and can self-reconfigure
to almost any compact goal shapes.
In Jones et al. (2003), the authors present a method to organize the iterations of self-assembly
agents to generate a consistent assembly of the desired goal structure. The decisions are made
by the agent docking in the existing structure and not by the structure. In other term, the
decision are made locally by each module in the system.
Another programmable matter module, the Robots Pebbles at MIT, was introduced in Gilpin
et al. (2010a), where each module has a size of 12 mm per side and is capable of creating a
2D shape by self-disassembly. The authors start with a latched system and the modular robot
detaches unnecessary modules.
Thalamy et al. (2019a) proposed an approach for accelerating self-reconfiguration by building

a porous version of the desired shape, using scaffolding. This method that constructs a
parametric scaffolding model, increases the parallelism of the reconfiguration, supports its
mechanical stability, and simplifies planning and coordination between agents. Each agent has
a set of basic rules using only four states which generates that module movements and the
construction of the scaffold is deterministic.
In Yim et al. (2001), the authors presented a probabilistic self-reconfiguration algorithm for
re-configuring rhombic dodecahedron modules residing in a Face Centered Cubic (FCC) lattice,
and that can only move using rotations. The authors also proposed the Goal-Ordering method.
In this method, the modules use one or two metrics to decide which target location in the goal
configuration they should go fill. This method, however, suffers from overcrowding around the
open goal positions and is likely to get stuck in local minima and avid converging altogether,
especially when the shape is solid and hollow.
Stoy, in his papers Stoy (2006); Stoy et al. (2004), approximated the target shape with a
porous representation made by removing individual modules from its volume in a manner that
would guarantee an absence of local minima and hollow or solid sub-configurations. He then
proposed to use local rules and cellular automata to perform the reconfiguration Stoy (2006),
or through a gradient descent method Stoy et al. (2004).
Recently, in Moussa et al. (2021) the authors propose a self-reconfiguration algorithm based
on clustering Bassil et al. (2020). The self reconfiguration is done in a parallel manner in each
cluster to find the final shape at the end. The proposed algorithm consists in moving the
robots that are not in the target shape in the interior of the current configuration in order to
fill target free cells.
The main approach discussed in the paper ? is a distributed algorithm to control block motion
of a reconfigurable micro-electro-mechanical modular surface. This proposed method uses an
asynchronous iterative election strategy which helps compute shortest path between two points
on the modular surface with minimum hop count. It also solves discrete trajectory optimization
problem and makes sure that it is scalable for larger systems as well. The main approaches
are: 1) A distributed algorithm is used to control block motion of a reconfigurable micro-
electro mechanical modular surface designed for conveying fragile and tiny parts with precision
accuracy. 2) Discrete Trajectory Optimization Problem: The proposed method uses an iterative
election process that computes the shortest path between two points using minimum hop
count strategy while solving discrete trajectory optimization problems efficiently. 3) Scalable
Methodology: Asynchronous Iteration Elections provide scalability making it suitable even
when dealing with large number of blocks or modules present within these types of surfaces
In this chapter, a hybrid algorithm using both centralized and decentralized decisions is pro-
posed. They are both used to reconfigure the robots into a goal structure with the least
possible cost. Distributed virtual forces algorithm with a Hungarian optimization approach are
used to limit overcrowding around the open goal positions and to avoid getting stuck in local
minima.
4.3. ASSUMPTIONS 73
4.3/ Assumptions
The modules used here are 2D node models with 4 connections that can rotate in Clock Wise
(CW) and Counter Clock Wise (CCW) directions, also can make a linear or circular translation
to move around other modules. The modules are placed on an unlimited grid, oriented along
the →
−
x, →
−y . The grid is defined by a large set of cells where each cell can only contain one
block. Each cell of the grid has only two different states: empty or occupied.
The position Pc of the cell c in the grid is given by coordinates in Z2 . Each block can be
directly connected to up to four neighbors in a 2D lattice. The following properties are then
applied:
• Unique ID;
• Same hardware executing the same software;
• Can get its orientation relative to global referential using embedded sensors;
• Detect the presence of docked neighbors in the adjacent cells;
• Communicates with its connected neighbors only;
Modules can move freely in different directions. They can only rotate in Clock Wise (CW) or
Counter Clock Wise (CCW) directions and can perform a translation or a rotation depending
on the pivot and near obstacles: so in total, they have 16 possible motions. The movement of
the modules needs to satisfy condition 1.
Condition 1 . A module can move freely without any manual intervention if there is only one
pivot in its neighborhood.
Condition 1 defines the case where a node has more than one neighbor that can be used as a
pivot and is not able to decide which one to use. Figure 4.1 shows an example of an invalid
case of movement. Indeed, the module 3 has as pivot module 1 and 2, it can not decide by
itself which node should be considered as a pivot. Whereas in Figure 4.2a and Figure 4.2b,
module 3, according to Condition 1, can pick the only neighbor it has like a pivot. Figure 4.2a
represents the case of a CW motion with rotation because the left side of the pivot is empty.
Figure 4.2b represents the case of a CCW motion with a translation because the right side of
the pivot is filled.
3 2
Figure 4.1: Invalid Node Motion according to Condition 1. The red module (#3) is a module
with 2 connections. Thus a pivot for rotation is not possible.
1 2 1 2
1 2 3 1 2
3 3
(a) Clock Wise (CW) direction and rotation. The (b) Counter Clock Wise (CCW) direction and
red module (#3) is a module with 1 connection. translation. The red module (module 3) is a mod-
Thus a rotation pivot can be identified and a rota- ule with 1 connection. Thus, a pivot can be iden-
tion is then possible. tified and a translation is then possible.
Let G be the goal shape, we assume that each module si stores locally a copy if G. A module
si has a position pi (xi , yi ), with (xi , yi ) ∈ Z2 . Furthermore, in this chapter, it is assumed that:
• The size of the system, as well as the initial shape of the system, is unknown.
• The leader is elected and can be any module in the system being at any position.
• Communication is only possible between adjacent neighboring modules.
• Each module in the system knows which connections it has at all times. This makes it
unlikely for any messages to be lost during transmission, so the system does not have to
worry about this issue..
• Each module can scan the grid and can check if a certain position (x, y) is empty or
filled.
• Each module has the ability to submit events to a scheduling queue for immediate or
future execution.
4.4. PROPOSED ALGORITHM 75
4.4/ Proposed Algorithm
The problem treated in this chapter is the following: having a goal shape G, the free modules
present in the grid will define the potential target positions inside G that they may fill by
applying the proposed algorithm. The leader will pick the free modules and the goal positions
to be filled in a way that minimizes the cost of the whole structure. However, after moving
some modules, the leader would be able to pick other potential nodes and fill new empty
positions. Therefore, the process will repeat itself until no further solutions are found by the
leader.
In this chapter, a deterministic self-reconfiguration algorithm, is proposed, based on virtual

forces and composed of two major phases: (a) Distributed calculation of the potential move-
ments of the free nodes, and (b) Centralized optimization of the overall movements of all these
nodes.
4.4.1/ Distributed Virtual Force Algorithm (VFA)
The first phase of the algorithm is split into 3 main steps:
1. VFA phase: each free node detects the free positions in the goal structure and for each
of them, it defines a weight as a result of the attractive and repulsive forces towards this
free position.
2. Exploration phase: the leader explores the whole system of modules while at the same
time builds a tree structure rooted at the leader module itself.
3. System potential movements reporting phase: This phase is launched in parallel to the
previous phase, in a manner where the algorithm collects all the free nodes’ potential
movements and their weights to report the total potential movements from the whole
system to the leader module.
4.4.1.1/ Phase 1: Virtual Force Algorithm
In modular robots, the proposed approach considers each free node as a ”source of force” for
all the empty positions in the target structure. This force can be either positive (attractive) or
negative (repulsive). On one hand, the attractive force is defined as being inversely proportional
to the number of moves required by this free node to reach a certain empty position in a specific
direction (CW or CCW); indeed, the more moves the node needs to reach the empty position
the less the force exerted is attractive. On the other hand, the repulsive forces are defined as
the existence of an invalid path in a certain direction according to Condition 1.
In a neighborhood of M modules, let j ∈ (CW : 0, CCW : 1) and let the total force exerted
−−→
by a node si on an empty position pk in a certain direction j be denoted by Fijk which is
a vector whose orientation is determined by the vector sum of all the forces exerted by si in
−−−→ −−−→
the direction j on the empty position pk . If FijkA and FijkR are considered, respectively, the
attractive force and repulsive force exerted by si in the direction j on the empty position pk ,
−−→
the total Fijk can now be expressed as:
−−−→ −−−→ −−→

FijkA + FijkR = Fijk (4.1)
−−−→
FijkA as defined previously is inversely proportional to the number of moves required by si to
reach the empty position pk while ignoring the Condition 1. Let be n the number of these
moves and M the number of modules:
−−−→ M
FijkA = + (4.2)
n
−−−→
FijkR is the existence of invalid path in a certain direction according to the Condition 1. It
can be expressed as follows:
⎧
−−−→ ⎨0, if from j to pk is a valid path
⎪
FijkR = (4.3)
⎩−M,
⎪
if from j to pk is an invalid path
−−→
A positive value for Fijk expresses the attractiveness of the motion of si in the direction j
−−→
towards pk , whereas a negative value for Fijk expresses that such a motion would result in
a blocking position for si and therefore should not be taken into consideration as a possible
motion for si .
1 1
1 2 3 1
1 1 2 3
2 F211A 4 F501A 5 F501R

4 F411A
(b) Attractive force

(a) Attractive force with 3 required with 1 required
movements movement (c) VF with a repulsive force
Figure 4.3: Repulsive and attractive VF
In Figures 4.3a, 4.3b, and 4.3c, the red module is a free module and the blue ones are in the
goal shape. The orange squares are empty positions in the goal shape that should be filled.
Figures 4.3a and 4.3b present attractive forces with the variation of the number of motions
needed to reach the target. Indeed, in Figure 4.3a the node s4 in the direction 1 needs 3 moves
to reach the empty position p1 with a total number of 4 modules in the figure, therefore the
−−−→
length of the vector F411A should equal to 4/3. Whereas in Figure 4.3b the node s2 in the
direction 1 needs 1 move to reach the empty position p1 with a total number of 2 modules in
−−−→
the figure, therefore the length of the vector F211A should equal to 2/1.
Figure 4.3c shows a case of attractive and repulsive forces. The node s5 in the direction 0 needs
4 moves to reach the empty position p1 if we ignore the Condition 1 with a total number of 5
−−−→
modules in the figure, therefore the length of the vector F501A should equal to 5/4. Whereas
the path to p1 following the direction 0 would cause a blocking position of s5 between s2 and
−−−→
s4, so the length of F501R would be equal to 5 in the opposite direction of the motion. In
−−→
this case, the sum of the forces F501 would be negative and ignored in the remaining phases
of the algorithms. Theoretically, if Condition 1 is not valid the value of the repulsive force will
be greater than the attractive one and the sum of forces would be negative, therefore in such
a case, it is useless to calculate the attractive force. Let’s define L as the 2D grid, G the goal
shape we aim to obtain, D the set of possible directions, P the set of available modules in L
and T the set of forces calculated by s.
The algorithm of the phase 1 is presented in Algorithm 13. Each module in L, will launch
this algorithm in the phase 1 and at the end of this phase each free module will have a set of
target empty positions with the required forces to reach them in a specific direction.
Algorithm 13: VF calculation for a module si

Result: T a set of forces calculated by s
1 T ←∅
2
3 if s.position is not in G then

4 for ( i=0; i<L.length; i++ ) {
5 for ( j=0; j<L.width; j++ ) {
6 FA ← 0
7 FR ← 0
8 if L[i][j] is empty AND L[i][j].position is in G then
9 for ( d=0; d<D.length; d++ ) {
10 n ← G.isV alid(s.position, L[i][j].position, d)
11 if n <0 then
12 FR ← −P.size
13 else
14 FA ← P.size/n
15 T [L[i][j].position][d] = FR + FA
4.4.1.2/ Phase 2: Exploration
Inspired from Assaker et al. (2020), this phase’s goal is to explore the whole system of modules
while building a logical tree structure rooted at the leader module along the way. The algorithm
starts with the initiation from the leader module and by using 3 types of messages:
1. Type 1 represents the discovery of new modules.
2. Type 2 messages reply by confirming that a new module has been discovered and it is
one of the children of the sender module.
3. Type 3 messages reply without taking into consideration that the recipient module has
already been detected and inform the sending module of this discovery.
Also, to notice that type 2 messages are the only way to expand the tree structure of the
system.
The leader module starts by specifying that it is now discovered and that it has no parent, and
would finally transmit type 1 messages to each of its neighbors. Whenever a module receives a
type 1 message it initializes its parent to be the sender module and replies by a type 2 message
which notifies the parent that this node is now one of its children, and finally proceeds by
sending type 1 messages to its neighbors (excluding the already known to be parent neighbor).
If it is not the first time that it receives a type 1 message (the module is already discovered
by another module) it sends back a reply message of type 3, which notifies the sender module
that this module is not its child.
The Algorithm’s part concerning the first phase is presented in Algorithm 14.
Algorithm 14: Exploration

1 is discovered ← f alse
2 leader ← f alse
3 parent ← −1
4 unique id ← −1
5 neighbours ← ∅
6 children ← ∅
7
8 if leader = true AND is discovered = false then

9 is discovered ← true
10 foreach neighbour in neighbours do
11 send type 1 message to neighbour
12 if received message then
13 switch message.type do
14 case 1 do
15 if is discovered = true then
16 send type 3 message to message.origin
17 else
18 is discovered ← true
19 parent ← message.origin
20 neighbours ← neighbours − message.origin
21 send type 2 message to message.origin
22 foreach neighbour in neighbours do
23 send type 1 message to neighbour
24 case 2 do
25 neighbours ← neighbours − {message.origin}
26 children ← children ∪ <{message.origin} >
27 case 3 do
28 neighbours ← neighbours − {message.origin}
4.4.1.3/ Phase 3: System Potential Movements Reporting
In this phase, that is run in parallel with the previous phase, the main idea is that whenever
a module is discovered and all its subsequent children finish discovering their respective sub-
trees (or if this module does not have any children), this module should report its sub-tree
potential modules movements to its parent. The sub-tree potential module’s movements of
a given module are the potential modules movements of the tree structure that is rooted in
this module. Thus, this process of sub-tree potential module movements reporting will emerge
from the leaves to the leader module. Type 4 messages are now introduced. These messages
are only passed from child to parent and they carry out a set value named that represents the
sub-tree potential modules movements of the child node. After a module has been discovered,
and it has sent out type 1 messages to all of its neighbors (potential children) and it received
back all the reply messages (either type 2 or type 3), it would if all neighbors replied with type
3 messages or if it has no neighbors other than its parent (both cases represent the case of a
leaf) send a type 4 message to its parent, with the set composed at the first phase. If one or
more neighbors replied with a type 2 message (i.e., the node has at least one child) wait for all
children to send their sub-tree potential modules movements, and only when they do, proceed
by sending a type 4 message to its parent, which now carries its sub-tree potential modules
movements that is the aggregation of all sub-tree potential modules movements received from
its children with its own. This process keeps on repeating until eventually all sub-tree potential
module movements would be transmitted from child to parent and the leader module would
be transmitted from child to parent and the leader module would receive the final total system
potential module movements The Algorithm’s part concerning the second phase is presented
in Algorithm 15.
Algorithm 15: System Potential Moves Reporting

1 sent ← f alse
2 moves ← ∅
3 if received message msg then
4 switch msg.type do
5 case 1 do
6 if is discovered = true then
7 ...
8 else
9 ...
10 if neighbours.size = 0 ∧ ¬sent then
11 Check()
12 else
13 foreach n ∈ neighbours do
14 send type 1 message to n
15 case 2 do
16 ...
17 case 3 do
18 ...
20 Check()
21 case 4 do
22 child ←find msg.origin ∈ children
23 child.moves ← msg.moves
24 moves ← moves ∪ {msg.moves}
26 Check()
4.4.1.4/ Centralized Hungarian Optimization
At this point, the leader has gathered all the system’s potential movements of free modules
towards empty positions in the goal structure. We define the cost of the algorithm as being the
total number of moves by all the different free modules. The problem that needs to be solved
now is to fill the highest number of empty positions while optimizing the cost of the algorithm:
it can be formulated as an assignment problem which can be solved using the Hungarian
Method Cui et al. (2016). The Hungarian method is one of the most popular polynomial-
time algorithms for solving classical assignment problem. As stated in the original algorithm
published in 1955 : ”Assuming that the numerical scores are available for the performance of
each of n persons on each of n jobs, the assignment problem is the quest for an assignment of
persons to jobs so that the sum of the n scores so obtained is as large as possible” Kuhn (1955).
In this chapter, the people are considered the modules, the jobs are the empty positions to be
filled and the performance is the result of the Virtual Forces phase. Theoretically, the Kuhn-
Munkres algorithm (Hungarian Method) is guaranteed to reach the global optimum. When
the leader has all the potential movements, it will launch the Kuhn-Munkres algorithm twice:
once in each direction (CW and CCW). To prevent unexpected collisions between moving
blocks, the approach needs to pick one direction at a time. The algorithm is searching for the
direction with the overall lowest possible cost on the system. Having that, the leader will be
able to identify which modules should be moved to which positions. When the leader moves
certain blocks, it may open the way to other blocked modules to be able to move, so the whole
algorithm may be repeated on several iterations until no further potential system movements
are provided by the environment exploration and reporting phases. The overall algorithm of
the proposed approach is presented in Algorithm 16.
Algorithm 16: Overall proposed approach

1 S←∅
2 best cost ← +∞
3 best solution ← ∅
4 T ← distributed algorithm of the first section
5 while T is not empty do
6 foreach direction ∈ {CW,CCW} do
7 S ← Kuhn-Munkres(direction)
8 if best cost >S.cost then
9 best cost ← S.cost
10 best solution ← S.solution
11 foreach s ∈ S do
12 Scheduler.push(Movement Event, s)
13 T ← distributed algorithm of the first section
4.5/ Simulation Results
The proposed algorithm was implemented and evaluated using VisibleSim Thalamy et al. (2021)
a modular robots simulator. To study the performance of the proposed algorithm, four metrics
were taken into account in our simulations: the number of iterations needed by the Kuhn-
Munkres algorithm; the number of moves made by all the modules; the number of messages
exchanged among the modules during the self-reconfiguration process and the number of events
processed by the simulator.
4.5. SIMULATION RESULTS 83
(a) The goal shape of UFC (b) The goal shape of a humanoid
Figure 4.4: Different goal shapes
To show that our approach works on different styles of shapes, we have conducted configu-
rations of varying complexity. A video of these simulations is provided 1 to better illustrate
the algorithm and the reconfiguration results. We considered two configuration scenarios while
varying the total number of modules. The first scenario is to transform a straight chain line
modular robot to a ”UFC” 2 like shape and the second to transform it to a humanoid shape
as shown in Figures 4.4a and 4.4b respectively.
The obtained results are presented in Figures 4.5 and 4.6. These figures show the number
of iterations, events, messages and moves for the two configurations ”UFC” like shape and
humanoid shape while varying the total number of modules. In the two scenarios, we notice
that the number of messages and moves to change the shape of a modular robot using our
algorithm is linear according to the total number of modules in the system which is a very
encouraging result comparing to the results presented in ?.
Modules Iterations Events Messages Motions

29 22 14,775 1,876 571
31 24 17,564 2,196 690
63 54 83,005 10,100 3,540
77 55 98,485 12,338 4,349
154 144 267,879 37,014 16,263
Table 4.1: Performance Evaluation for the whole algorithm on different versions of the modules
structure
1
Youtube video: https : //youtu.be/f wKvdF 3zDk
2
Acronym of our University: University of Franche Comté
212156
27226 55249
32965
7867
3439 17766
3226
1163
112
29 35
0 20 40 60 80 100 120 140 160 180

Number of Modules
Number of Iterations Number of Events Number of Messages Number of Motions
Figure 4.5: Simulation Results of the ”UFC”-like shape.
83005 98485 267879
17564
12338 37014
10100
16263
14775 2196
4349
1876 3540
690
571
144
54 55
24
22
0 20 40 60 80 100 120 140 160 180

Number of Modules
Number of Iterations Number of Events Number of Messages Number of Motions
Figure 4.6: Simulation Results of the humanoid shape.
4.6/ Conclusions
Modular robots are limited in computational resources. The problem, that our solution does not
take into consideration, is the complexity of the optimization algorithms. Usually, optimization
algorithms are of the order of O(n2 ) and above; the Hungarian method is of complexity O(n3 ),
so it is not so suitable for modular robots. In ?, they proposed an improvement of the Kuhn-
Munkres algorithm by utilizing the sparsity structure of the cost matrix, but it should be tested
4.6. CONCLUSIONS 85
on the modular robots to see if it gives any possible enhancements.
This chapter presented an algorithm for a system of modular robots that is capable of self-
reconfiguration based on a distributed virtual forces approach and a centralized optimization
method. The proposed algorithm tries to move the maximum number of free modules to empty
positions inside a goal shape over multiple iterations if required. The results show that the
algorithm has a linear consumption of messages over the distributed phase and will increase the
resources consumption with the number of iterations required which is related to how much
the initial shape is different from the goal shape.
5
Fault detection
Contents
5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
5.2 Background . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
5.3 Detector: disconnection detection . . . . . . . . . . . . . . . . . . . 89
5.3.1 Definitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
5.3.2 The Proposed Algorithm . . . . . . . . . . . . . . . . . . . . . . . 92
5.4 Simulation Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
5.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
87
88 Fault detection
ne of the main challenges in modular robotics is to detect and heal the system from a state
O of partial or complete disconnection. Partial disconnection can be achieved by removing
the links between the modules. Complete disconnection can be achieved by removing all the
connections between two group of modules. It is important for the modular robots to detect a
failure between connections since the mobility and the functionality of the robot depend on it.
This chapter presents a novel approach to detect disconnections in lattice based modular robots
more precisely, Blinky Blocks. It detects the disconnections using a hierarchical algorithm.
The leader of the system constructs a spanning tree, assigns a coordinate to each module and
compares it to detect the disconnections. The simulations shows the ability to detect all partial
disconnections. Furthermore, the complexity regarding the number of messages sent is linear
against the number of modules in the system.
5.1/ Introduction
A very frequent fault in modular robots is disconnection. It can be caused by incorrect design,
lack of care, or a defective module. Disconnections among robots can lead to collisions or
a lack of mobility, which will make the robot unable to perform its function. Disconnections
can also cause a loss of autonomy or even the robot’s death. Therefore, it is crucial to detect
disconnection among modular robots to prevent errors in the overall system. This chapter
proposes a novel hierarchical disconnection detection algorithm based on spanning tree that
detects all partial disconnections in a lattice based modular robotic system.
The remainder of this chapter is as follow: Section 5.2 presents the literature review, Section
5.3 presents the proposed algorithm, Section 5.4 shows the simulation results, and finally
Section 5.5 concludes the chapter.
5.2/ Background
In modular robotics, the mobility of the modules is often not controlled by the computer itself,
but the modules communicate among each other and decide among themselves how to move.
Simple tasks such as collision detection, passing obstacles and shape formation become more
complex with this approach.
Disconnections in MRS can occur for a number of reasons: (1) a robot may move off-course,
(2) a robot may collide with a fixed structure, (3) two robots may physically touch each
other, (4) two robots may physically touch each other and then become disassociated from
the system, and/or (5) a robot may disconnect from the system through no fault of its own.
While a MRS is being operated, the system must ensure that all communications remains
available. In order to achieve this, it is crucial to detect disconnections among the robots of
5.3. DETECTOR: DISCONNECTION DETECTION 89
the system. Such disconnections may, for example, result in the loss of valuable data that is
being transferred among the particles, or in the loss of robot operation time.
A MRS can be represented as an undirected graph, but traditional graph algorithms, such as
Weakly Connected Components Dunbar et al. (1997), can’t be applied due to the system’s
distributed nature.
In Youssef (2021), the authors presented a machine learning based algorithm to detect faults
in distributed robotics system. Their work can be summarized as follows: creation of data-sets
of multi-robot system with faults and failures for the purpose of learning faults.
In Regin et al. (2021), fault detection over a wireless sensor network in a fully distributed
manner. First, they proposed the Convex hull algorithm to calculate a set of extreme points
with the neighbouring nodes and the duration of the message remains restricted as the number
of nodes increases. Then they proposed a Naı̈ve Bayes classifier and convolution neural network
(CNN) to improve the convergence performance and find the node faults.
In Ahmad et al. (2013) a distributed fault detection scheme for MRS and Modular Reconfig-
urable Systems (MRR) with joint torque sensing was proposed. With the proposed scheme,
the joint torque command is filtered and compared with a filtered torque estimate derived from
the nonlinear dynamic model of MRR with joint torque sensing. Common joint actuator faults
are considered with fault detection being performed independently for each joint module. This
algorithm detects if the physical connectors of the particles are connected. In some cases we
might have a successful physical connection but the communication can still be down.
This chapter will be presenting a novel algorithm that detects disconnections in lattice based
modular robots. The algorithm starts by constructing a spanning tree with the leader as root.
Then, starting from the leaves, each module will send the list of none existing neighbors to
their parents. Each parent will compare the received list with the list of the existing neighbors
to detect any disconnections
5.3/ Detector: disconnection detection
This section will introduce the proposed algorithm. Lets start by presenting some definitions
and terminologies.
90 Fault detection
5.3.1/ Definitions
Definition 12: Partial disconnection
A partial disconnection is a set of nodes that are not connected to each other but
are able to communicate through other common nodes on the system. Figures 5.2a
and 5.2b shows an example of partial disconnection.
Definition 13: Complete disconnection
A node is referred to be in a state of complete disconnection when it looses connec-

tions with all its neighbors. Making it impossible to be identified by the system and
will be in a state of complete isolation. Figures 5.2c and 5.2d shows an example of
complete disconnection.
Definition 14: Lattice architecture
The units of a lattice architecture link their docking interfaces at points into virtual
cells of a regular grid. This network of docking sites is analogous to atoms in a crystal,
and the grid to the crystal’s lattice. As a result, the kinematical characteristics of
lattice robots may be defined by their corresponding crystallographic displacement
groups (chiral space groups). Typically, just a few units are required to complete a
reconfiguration stage. Lattice designs provide a simpler mechanical design as well
as a simpler computational representation and reconfiguration planning that can be
scaled more readily to complex systems.
Definition 15: Density
The density of a modular robotic system shows how scattered are the modules. The
value of the density ranges between 0 and 1. A system is considered to be dense
when its density value is close to 1. The coordinates assigned to the modules do
not take into consideration the size of the module. Each module is considered to
have one unit size. Equation 5.1 shows how to compute the density in a system. N
represents the total number of modules. xmax , ymax , and zmax depicts the maximum
coordinates in the lattice and xmin , ymin , and zmin depicts the minimum coordinates
in the lattice.
N
Density = (5.1)
(xmax − xmin + 1) ∗ (ymax − ymin + 1) ∗ (zmax − zmin + 1)
Definition 16: Potential neighbors
A potential neighbor defines a side of the robot that is not connected. A potential
neighbor is defined as the not connected side of the robot. Two cases are presented,
connection failure or absence of modules. Let’s take module B in Figure 5.1 as an
example. Module B in this condition has two potential neighbors: The none existing
one on the right side and the disconnected one-Module D-.
A B
Figure 5.1: Potential Neighbors

92 Fault detection
(a) (b)
(c) (d)
Figure 5.2: Different examples of Partial and complete disconnections: Figures 5.2a and 5.2b
Represents a partial disconnection. In Figure 5.2a. modules A and B are disconnected, but
they still are part of the whole system since they can maintain their connection to the system
through their neighbors C and D. Figures 5.2c and 5.2d are in a state of complete disconnection.
In Figure 5.2c, module A is disconnected from module B and module A is not connected to
any other module. Therefore, module A is considered to be in complete disconnection from
the system since there is no other way for the system to acknowledge its presence. Same case
for Figure 5.2d.
5.3.2/ The Proposed Algorithm
This section will be describing the proposed solution in details. The algorithm is based on
three phases.
• Phase 1: Spanning tree creation and coordinate distribution;
• Phase 2: Neighbors’ Data Collection;
• Phase 3: Disconnection detection. Below is a detailed explanation of the phases.
Table 5.1 depicts the different states of the interface in a specific module.
Status Definition
0 interface not connected
1 interface connected to parent in the spanning tree
2 interface connected to child
3 interface connected to neighbor that is not a child nor a parent
Table 5.1: Interface status
5.3.2.1/ Spanning tree creation and coordinate distribution
The leader of the system initiates the algorithm. It will create a spanning tree containing all
the modules in the system. The process starts by sending a recruitment message to all its
neighbors. Once a module receives a recruit message, it will change the recruited flag to 1,
to prevent future recruitment from other modules. Mark the interface that sends the recruit
message as parent interface. Extract the coordinates from the received message and update
the coordinates based on the received direction in order to generate its own coordinate. And
finally, send a recruit message to all its neighbor except for its parent. Diagram 5.3 shows in
details the behavior of a module once it receives a recruit message.
94 Fault detection
Recruit Msg
Yes
notRecruited No Reply with already

&
recruited
not leader
Yes
recruited = true;
parent = sender;
interfaceStatus[sender] = 1;
receivedDirection = getDirection(sender);
setCoordinates()
Send recruit message No

to neighbors except iAmLeaf()
parent
Yes
getPotentialNeighbors();
sendNeighborsInfoToParent();
Figure 5.3: The recruitment process diagram.

Algorithm 17: Received recruit message

1 if received message is a recruit message then
2 if Not recruited and not leader then
3 recruited = true
4 parent = sender
6 receivedDirection = getDirection(sender)
7 x = msgData.getX()
8 y = msgData.getY()
9 z = msgData.getZ()
10 switch receivedDirection do
11 case 0 do
12 setCoordinates(x, y, ++z)
13 case 1 do
14 setCoordinates(x, –y, z)
15 case 2 do
16 setCoordinates(–x, y, z)
17 case 3 do
18 setCoordinates(++x, y, z)
19 case 4 do
20 setCoordinates(x, ++y, z)
21 case 5 do
22 setCoordinates(x, y, –z)
23 otherwise do
24 Break
25 if i am leaf then
26 gatherNeighborsInfo()
27 sendNeighborsInfoToParent()
28 else
29 Send recruit Msg through the connected interfaces except parent interface
30 Inform parent that the recruitment was acknowledged
31 else
32 Reply back with already recruited
5.3.2.2/ Neighbors’ Data Collection
The proposed suggestion to find disconnections in a system is to gather information about the
neighbours. The process starts with the leaves. Each leaf will generate the coordinates for its
potential neighbors, add those coordinates into a vector - that will be called potentialNeigh-
96 Fault detection
borsVector - and send this vector to its parent alongside their own ID and coordinates. Each
parent will also generate the potential neighbors coordinates, check for possible disconnections
- explained in Subsection 5.3.2.3 - then send the results to its parent. The same process will
be repeated until the vector reaches the leader. Figure 5.4 shows an illustrative example of
this phase.
2 5 6
(0,1) (1,1) (2,1)
Leader
1 4 8 Module
(0,0) (1,0) (2,0)
Leaf
3 7 9
(0,-1) (1,-1) (2,-1)
Figure 5.4: Data collection in a dense system: Module 6 will add to the potentialNeighborsVec-
tor the following coordinates: (2, 2) and (3, 1), Module 8 will add (3, 0) and Module 9 will add
(3, −1) and (2, −2). They will then send this vector to their respective parents 5, 4, and 7.
Module 5 will add (1, 2), Module 7 will add (1, −2), and Module 4 will not add anything since
all its interfaces are connected. So on until this vector reaches the leader.
5.3.2.3/ Disconnection detection
Once a node receives from all its children the vector potentialNeighborsVector, it will compare
with the list of coordinates of existing modules. If the node finds potential neighbors coordi-
nates matching with existing modules, then there is a disconnection. Since each node have
access to only its children, then the final decision of disconnection is actually at the leader’s
level.
5.4/ Simulation Results
The proposed algorithm was implemented and evaluated using VisibleSim Thalamy et al. (2021)
a modular robots simulator. To study the performance of the proposed algorithm, the metrics
that were taken into account in the simulations are the number of messages and the percentage
of error detected (number of errors detected by our algorithm on the total number of errors in
the system). Multiple simulations where done while varying different components at a time.
The first bash of simulations was for the same number of modules - In those simulations, the
number of modules was 1,000 −with different densities ranging from 0.18 to 1. All the shapes’
configuration were randomly generated - For the exception of the cube since it is the only
shape where the density is to its maximum-.
Figure 5.5 shows that when the density is increasing, the number of messages sent is also
increasing. This is due to the fact that when the density is high, the modules are closer to
each other, leading to an increased amount of neighbors per module wish will lead to a higher
number of messages sent. Further more, Figure 5.5 shows that whenever the percentage of
errors in a system is higher, the number of messages sent is lower. The reason behind this is
that when modules are disconnected they can not send messages which will decrease the total
number of messages sent.
Figure 5.5: This figure shows, on a logarithmic scale, how the number of messages sent in
a 1,000 3D system is changing with the density of the system. Each color represents the
percentage of errors that existed in the system during the simulations. It is noticeable that
the number of messages is increasing with the density. Furthermore, the number of messages
decreases when the percentage of errors is increasing
98 Fault detection
The second bash of simulations were done for the same density while increasing the number
of modules. The chosen density for this simulation was 1, for the reason that it was the value
where the system was sending messages the most. We noticed that the number of messages
is increasing linearly with the number of modules. This shows that the complexity of the
proposed algorithm, regarding the number of messages sent, is linear. It is also noticeable that
when the number of errors is increasing in the system, the number of messages in decreasing.
This is due to the fact that some messages are not able to be sent or delivered due to the
errors encountered in the system. 5.6
Figure 5.6: This figure shows, on a logarithmic scale (Natural log on the X axis), the number
of messages sent in the system according to the number of modules in a logarithmic scale.
The shape used in those simulation was a cube. The colors represent the percentage of errors
in the system during the simulations. The results shows that the number of messages sent is
linear when compared to the number of modules in the system.
During the previous simulations, the simulator collected the total number of errors detected
by the proposed algorithm. Figure 5.7 shows the percentage of errors detected on the Y axes
ranging from 90 to 100 against the density, on logarithmic scale, from −2 to −0.4. Five colors
are shown on the graph. Each color represents the percentage of errors in the system. Figure
5.7 shows that for high densities, more errors are detected. A system with low density has less
connected modules. Any occurring error might lead to a complete disconnection that is not
detected by the proposed algorithm. Therefore, the higher the density the better the detection
of errors is.
Figure 5.7: Percentage of errors detected. This figures shows the percentage of error detected
100 Fault detection
5.5/ Conclusion
This chapter presented Detector, a novel distributed algorithm for a hierarchical fault detection
in modular robots. The proposed algorithm is able to detect partial disconnections in a lattice
based modular robotic system. To achieve such task, the algorithm creates a spanning tree
having the leader as root. Each module generates its coordinates starting from the leader as
origin. Then, each module - starting from the leaves - will send the potential coordinates of
none connected interfaces to its parent. The parent will also generates the potential neighbors’
coordinates and add them to the received list, compare the list of potential neighbors’ coordi-
nates with the list of the actual coordinates. Any matching coordinates means a disconnection
is found. Then, the parent, sends the remaining results to its parent, so on until it reaches the
leader who will have the final decision regarding the existence of disconnections if any.
The simulation results show an elevated rate of disconnection detection specially with a high
density system. The accuracy of finding disconnections was ranging from 90% to 100%.
Furthermore, the simulations also showed that the complexity of the algorithm regarding the
number of exchanged messages remains linear. However, when this system scales up, the
number of coordinates that needs to be transferred to the leader becomes high. Therefore,
with the limited memory that the system has, this solution is not ideal for a high number of
modules. Since this algorithm is specially made for Blinky Blocks, this issue should not be a
concern for now.
6
PROLISEAN
Contents
6.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
6.2 Background Description . . . . . . . . . . . . . . . . . . . . . . . . . 103
6.2.1 Lightweight cryptography . . . . . . . . . . . . . . . . . . . . . . . 103
6.2.2 Hardware consideration . . . . . . . . . . . . . . . . . . . . . . . . 105
6.3 PROLISEAN: our proposed protocol . . . . . . . . . . . . . . . . . . 106
6.3.1 Risk study through EBIOS method . . . . . . . . . . . . . . . . . . 106
6.3.2 Proposed algorithm: PROLISEAN . . . . . . . . . . . . . . . . . . 110
6.3.3 Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
6.4 Algorithm analysis and proposed solutions . . . . . . . . . . . . . . . 123
6.4.1 The block cipher . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
6.4.2 The Hash function . . . . . . . . . . . . . . . . . . . . . . . . . . 126
6.4.3 Proposed Hashing function . . . . . . . . . . . . . . . . . . . . . . 128
6.5 Simulation and differential cryptanalysis . . . . . . . . . . . . . . . . 129
6.5.1 Simulations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
6.5.2 Differential cryptanalysis . . . . . . . . . . . . . . . . . . . . . . . 131
6.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
101
102 PROLISEAN
ust like any other technology, the security aspect in programmable matter is a huge concern.
J Given its distributed architecture and its processing limitations, this development suffers
from a major security problem. To the best of our knowledge, no security protocols were used
in PMS. Traditional security protocols and encryption algorithms are not reliable in the way of
its distribution between the objects. This chapter proposes a new security protocol optimized
and dedicated for programmable matter. This protocol is based on light weight cryptography
and uses the same encryption protocol as a hashing function while keeping the distributed
architecture in mind. The analysis and simulation results show the efficiency of the proposed
method and that a supercomputer will need about 5.93 × 1025 years to decrypt the message.
6.1/ Introduction
Modular robots can be used in unattended even hostile environments, thus leaving them vul-
nerable to passive and active attacks. For instance, if MRS was used in space shuttles, a
hacked module can lead to sending falsified coordinates leading to a possible crash, or a nano
robot that is injected in the human body and starts killing healthy cells. Therefore, the security
in such scenarios is a necessity especially in the context of modular robots where modules have
resource-constraint, and are susceptible to physical capture. To the best of our knowledge,
security in modular robots is not yet tackled by researchers. Many challenges are encountered
when discussing such matter. This kind of robots have no central control and have limited
memory and processing resources. Under such circumstances, traditional security protocols
cannot be applied. Therefore, lightweight security protocols must be proposed and studied.
Such protocols were proposed in the context of wireless sensor networks Guyeux et al. (2014);
Santos-González et al. (2020); Bahi et al. (2010), ad-hoc networks Ogundoyin (2020) and In-
ternet of Things (IoT) Sarker et al. (2020); Wazid et al. (2020). Although, modular robots, are
considered to be an application of IoT, they have some specific characteristics. For instance,
the robots used in this thesis can not have a unique identifier or IP addresses. Moreover, they
are not always connected to the internet and do not have a central control. Therefore, existing
security protocols for IoT can not be applied for programmable matter.
The main contribution of this chapter is to study and propose the first security protocol that
can overcome the challenges mentioned above while keeping the system secure. It is based on
the creation of a hashing function using the encryption algorithm and a block code already
embedded in the nanobot to reduce the memory and processing usage. This protocol will be
composed of two main parts: authentication and encryption. In the authentication part, the
algorithm will be checking whether the connected module is authentic. In other words, check
if this module is an eligible module and that it has the right to connect to the system. Once
all modules are authentic, the second step will be encrypting the communication among the
modules, thus making it hard for a third party that might be listening to the communication
6.2. BACKGROUND DESCRIPTION 103
to understand the behaviors and the decisions of the system. The efficiency of the proposed
protocol was proven via an analysis study and validated experimentally via simulations realized
by VisibleSim Piranda et al. (2016), a simulator dedicated to modular robots. The obtained
simulation results show the effectiveness of the proposed approach which ensures the security
of a modular robot system.
The remainder of this chapter is organized as follows. Section 6.2 of this chapter describes the
background behind this study by reviewing modular robotics and light weight cryptography.
Section 6.3 is the main section of this chapter. It will be discussing the proposed protocol
with four different versions. And a full risk study through EBIOS method for all the versions
proposed. Section 6.4 will be analysing the proposed protocol based on the CIA criteria while
taking into consideration the hardware and logical limitations. Section 6.5 will be analyzing
the HIGHT encryption algorithm by trying nine different attacks. And finally Section 6.6 is
dedicated to the conclusion and future work.
6.2/ Background Description
6.2.1/ Lightweight cryptography
In the wake of the massive arrival of small connected devices on the market with small capabil-
ities but sensitive information to communicate, IoT became an easy target for cyber-attacks.
Therefore, various algorithms and protocols have been developed over the past years to secure
those communications. Regarding the low capacities of the devices compared to a laptop or
a smartphone and the need of authentication, the use of cryptography appeared as a good
solution. Since security algorithms -in this particular case – have to use less memory and
have a low complexity to reduce their power consumption, a new kind of ciphers merged: the
lightweight cryptography.
104 PROLISEAN
Figure 6.1: Results of ECRYPT II ordered by code size and RAM use
Cryptography consists in encrypting data into ciphered text to secure transmission and there
are two types of encryption algorithms, symmetric and asymmetric. Symmetric ciphers use the
same key for encryption and decryption of the data. Sharing the key is the major issue of this
type since its acknowledgment by a malicious party compromises the system. Symmetric key
algorithms allow confidentiality of data but can not guarantee authentication, this has to be
done before the communication begins Bhardwaj et al. (2017); Katagi et al. (2008); Hanley
et al. (2012); Shirai et al. (2007). Asymmetric cipher needs two keys: a private and a public
one. Each device has to know all the public keys of the network, this becomes a structural issue
for nano-modular robots which theoretically includes billions of nano-modules. Therefore, this
chapter will be focusing on symmetric algorithms Biryukov et al. (2017). Figure 6.1 shows the
results of different reports on lightweight cryptography algorithms and among all, the report
of the European Network of Excellence in Cryptology Francois-Xavier Standaert et al. (2010)
that bench-marked 11 different algorithms. This research focused on this type of encryption
since all the algorithms were tested on a very low resources processor the ATtiny45 by the
corporation ATMEL (Advanced Technology for Memory and Logic). It is an 8-bit processor
made by ATMEL, with a limited number of instructions, a 256 Bytes internal SRAM, and 4
KB of flash memory. 19 hash-functions designed to be lightweight protocols are compared.
Those are interesting in this study since there is no need for a key to use hashed data even
if the decryption is too complicated for the nano-modular robots. The diagram in Figure 6.1,
sorts all the applications by code size and RAM usage (in bytes) to restrain the list to the one
that could fit in the nano-robots without impacting their memory capacity.
6.2. BACKGROUND DESCRIPTION 105
In this chapter we proposed a new security protocol for programmable matter based on modular
robots with low energy and computation resources. Similar studies were proposed for different
technologies such as RFID, wireless sensor networks (WSN) and Internet of things (IoT). For
instance, in Arış et al. (2015), the authors describe a counter measure to prevent DoS/DDoS
attack. The authors suggested the addition of an extra filter to determine a possible DoS attack
and inform the routers to shut it down. In Cekerevac et al. (2017), the authors suggested first
an installation of firewalls and updating software regularly from reliable resources. On another
note, the paper recommended the usage of SSL certificate and efficient encryption algorithms.
Using event detection techniques in wireless sensor networks, the authors in Illiano et al. (2015)
developed an algorithm to detect malicious data injections. Malicious code injection attack
is one where an attacker can determine the configuration of a system and create falsified
measures allowing himself to bypass the security protocol.
Although the proposed techniques ensure good results in preventing several attacks, they can
not be applied directly in the context of programmable matter. Hence, programmable matter
have specific characteristics making them different from existing technologies. For instance, the
communication between modules are done just between adjacent modules, the topology is very
dynamic as the modular robot usually changes its shape, there is no base station to control the
network, etc. Based on the study published in Kumar et al. (2020), we proposed in Table 6.1 a
comparison between different technologies where lightweight cryptography protocols have been
used (e.g. Radio-frequency identification (RFID), wireless sensor networsk (WSN), Internet of
Things (IoT)) while adding the programmable matter (PM).
Mobility Support DB required Power requirement Popular Encryption Algorithms Possible Security Techniques
Usually passive DES, AES, Optimistic trivial RFID
Yes: modules are in form of
RFID Yes but sometimes SecureRF, authentication protocol
tags and are attached to objects
Battery-powered DESL (O-TRAP)
Route optimization algorithm,
they are usually placed DES, 3DES, DES-X, blowFish, active trust,Q-s composite,
WSN Yes Battery-powered
in fixed areas TEA, XTEA, AES, HIGHT TinySec, SPINS, LSec,
LISA, LISP
REST, HTTP, JWT, CWT,
IoT Modules can be mobile or fixed Yes Battery-powered ECC, Diffie-Hellman, COSE
WebSockets, TLS, DTLS
PM Modules can be mobile or fixed No Battery-powered HIGHT PROLISEAN
Table 6.1: Comparison among different technologies.
6.2.2/ Hardware consideration
Considering the size of the modules, one may understand that the hardware capacities will be
extremely low even if none of those has been built yet. In order to start the research with realistic
figures, the hardware capacities of the small modular robot that is being built by FEMTO-ST
was taken into consideration. The processor is an Arm® Cortex®-M0, a 32-bits one, with
36 KB RAM memory and 128 KB flash memory. It is one of the world smallest computers, and
with its low energy consumption equips all the recent TI calculators. This robot is similar to the
Blinky Block cubic modular robot proposed in the Claytronics Project Kirby et al. (2011) but
106 PROLISEAN
does not perform movement operations. This data is the only concrete information available
to the research department at the time of writing this report. The remaining features of this
report will be based on hypothetical values. Assuming that the day such a technology will
exist, it will consist of the smallest available electronic components. This chapter is based on
orders of magnitude based on the capabilities of the smallest electronic components currently
available.
6.3/ PROLISEAN: our proposed protocol
6.3.1/ Risk study through EBIOS method
To begin with, it was necessary to identify potential threats to programmable matter based
on modular robots. In this section, the elements will be summarized using the EBIOS ANSSI
(2010) method as shown in Figure 6.2. This method, created in 1995 and updated in 2010,
is a memento for studying security risks for designing and engineering projects in information
technology. The risk study of this method must be preceded by 3 steps: context study, study
of threat scenarios and study of feared events.
Threat
scenarios
General Risk Security
Context Dreaded assessment measures
events
Figure 6.2: EBIOS Process
6.3.1.1/ Dreaded events
The main dreaded events can be summarized as follows:
• Loss of spatial landmarks: the spatial location by the entire structure is an important
element in coordinating the individual actions of robots.
• Desynchronization of robots actions: although robots work individually, their action is

useless if it is not coordinated with others.
• Data leak: internal communications within the structure are read by people or algorithms
that should not be allowed to know the intentions of the structure.
• Distribution of messages from the outside: the modules receive instructions from a third
party.
6.3. PROLISEAN: OUR PROPOSED PROTOCOL 107
6.3.1.2/ Threat scenarios
Robots communicate through physical connectors by contact with their direct neighbours.
They can only send a message to one of their neighbours or to the entire structure through
their neighbours. As described previously, the modules are homogeneous and autonomous.
The threat of remote interference in robot communications can therefore be ruled out. The
main threats remaining are:
• The mixture of two different structures: causing misunderstandings between the modules
because they would be linked with others with different behaviors, as shown in Figure 6.3.
Or worse, if this second structure is controlled by a malicious person, it could transmit
our internal information to its user, interfering with the execution of the mission.
Forb
idde
n
Figure 6.3: Connection between two different structures
• A spy in the structure: A hacker builds the same modules as those in our structure
but equipped with an antenna and an interface, as shown in Figure 6.4. It could then
connect, integrate into it and communicate with it to either take control or destabilize
it. For example, it could claim to be the leader of the structure while another leader has
been appointed.
Figure 6.4: External robots spying the structure
• An intruder: An identical robot is sent to the structure by a malicious user, as shown in

Figure 6.5. Its hardware is exactly the same, only few lines of its source code are different.
Once connected, this intruder spreads malicious information to the whole structure to
destabilize it. It could, for example, claim that it is the actual “leader” whereas another
already exists or transmits wrong coordinates to its neighbours.
108 PROLISEAN
(2,0)
(1,0) (4,3) (4,4) (4,5) (4,6)
(0,0) (0,1)
Figure 6.5: An intruder transmits wrong coordinates to its neighbours
6.3.1.3/ Risk assessment
Such a risk study is carried out in two parts: the analysis of the combined risk of scenarios
and feared events with or without the security measures already in place. After considering
the 3 elements of the threat scenarios, the risks are defined and classified by category and
probability.
• Hacking the structure with no physical help: it has been demonstrated in previous sec-
tions that it is currently impossible to communicate with robots from a computer when
the experiment is in progress. In this case, if a computer manages to get into a robot,
it will not be able to take control of the entire structure. The probability is therefore
negligible, and the risk is low. However, in another experimental context, where the
structure would communicate directly with a computer, this risk would become one of
the main concerns.
• Mixing two different structures of modules: these are two blocks of programmable matter
moving nearby and composed of similar robots. It is then very likely that they will mix
if they come into contact. The robots that compose them would stick together without
understanding each other and the work of the two structures would be interrupted. The
gravity of this case is not significant.
• Intentionally send a group of modules to insert into the structure: this risk is almost
similar to the previous one, except that if the malicious structure has been programmed
to come into contact with another, then its impact on its initial task will be more serious
because it will be more incapacitating.
• Inserting a new module equipped with a communication interface: this risk, although
unlikely because it is technically very complicated, would have critical consequences on
the functioning of the programmable matter because it would allow another user to
communicate with it and possibly divert it from its initial task or even destroy it.
• Inserting an identical module with wrong spatial coordinates in its code: this is more
likely to happen than the previous one because it is easier to implement. However,
the consequences would be a little less serious because the result would be at worst a
deformed structure (topology) preventing the system to perform its task or an outgrowth
on the final result.
Table 6.2 presents all considered risks, classified by category and probability.
Risk Assessment
Inserting a robot
Critical equipped with a
communication interface
Category
Inserting an identical
Intentionally send a
robot with wrong
Significant group of robot to
spatial coordinates
insert into the structure
in its code
Mixing two different
Limited
structures of robots
Hacking the structure
Negligible
with no physical help
Negligible Meaningful High Maximal
Probability
Table 6.2: EBIOS risk assessment
Despite the low hardware capacities, it is better to create simple rules applied by the modules
that would seal the structure to any exterior threat. Each module works independently in the
structure, it neither considers its orientation nor its place in the structure. Therefore, each
module is concerned by securing the itself and the whole system. Moreover, block ciphers use
less capacity than hash functions but needs to share its key to communicate data. Thus, a key
is needed as well as a way to communicate it and a secured mean of authentication. Therefore,
the system would be locked, no intruder could take part of the structure and nothing could
interfere into the communications.
Indeed, some systems may need minimum security which does not affect the robots capacity,
while others need a major security protocol even if it implies slowing down the robots and
consumes more energy.
Thus, the work describes four different versions that can be used separately and based on
ISO/CEI 27001 that respects the main requirements in cybersecurity: Confidentiality – Integrity
– Availability.
110 PROLISEAN
6.3.2/ Proposed algorithm: PROLISEAN
PROLISEAN stands for Protocol of Lightweight Security Embedded in an Architecture of

Nanobots. It is a protocol for nano modular robots designed to offer the smallest footprint
possible while providing a strong level of security against hacking.
Four versions of the protocol are proposed in this chapter starting with the least to the most
secured. The first version represents a simple authentication process. Protocols are more and
more secure as we move to the next versions. In other words, the version that is less secure
requires less processing power than the others. Therefore, the presentation of four versions
was mandatory, leaving the choice to the end-user based on his system.
6.3.2.1/ Version 1: Simple authentication
Initial concept When two robots connect, none of them knows if the other one belongs to its
own structure. In order to authenticate, each robot will provide its source code to the other to
compare it with its own. Since each robot from the same structure have the same source code,
the comparison of the code is an efficient way to authenticate without adding any unnecessary
lines in their program. However, if the Unknown-bot was malicious, this operation would turn
into a data leak. Therefore, hashed source code is shared. Since a hash function gives the
same result for the same data block, a comparison can occur. In this context, collision risk
probability must be taken into consideration while pointing out a light weight hash function.
Analysis This method allows to authenticate by comparison of the code with a few means
and without providing the code to a malicious robot. Once the authentication is done, the
flow of data is not protected but for a low security level. In fact, only identical robot can
authenticate and this might be enough to consider for some systems.
This version has low security dialog that does not guarantee the integrity of the mean of
connection. However, it remains important as it allows to make a difference between the robots
that belong or not to the structure. It was designed to be time efficient for authentication by
providing a first level of confidentiality.
6.3.2.2/ Version 2: Authentication and Ciphering
Phase 1: Authentication The first phase of this version is extended from the previous.
Moreover, the first part of the source code is hashed and used for authentication comparing
and the second part is saved in the robot’s memory because of its key role in the next phase.
The latter will be called “identity-block” in the following parts. Figure 6.6 presents the first
phase of version 2.
Nanobot 1 Unknow-bot
Source Code comparison Hash Code Source Code
+ Validation() << dataFlow >> + Validation()
0..1 0..1
+ comparison + comparison
0..1 0..1
Hash Function Hash Code Comparison Hash Function
<< dataFlow >> + Validation()
Figure 6.6: Functional scheme of the first phase of version 2
Phase 2: Encrypted communications Once the nanobots are connected, the block cipher
algorithm takes over the hash function to carry the communications out. As the block cipher
is a symmetric algorithm it needs a common key in each nanobot. Therefore, the “identity
block” previously created is used as a session key to encrypt the data. In this study, the robots
can be connected to many other robots at the same time and the use of the same key for all
the communications allows to save memory space and the energy that would be necessary to
create and use one new key for each data transfer with a new robot. Figure 6.7 presents the
second phase of this version.
Nanobot A Nanobot B
Block-Cipher Block-Cipher
Identity Block 0..1 Identity Block 0..1
0..1 0..1
+ Encryption() + Encryption()
+ Key: String + block-cipher + Key: String + block-cipher
+ Decryption() + Decryption()
0..1 0..1
+ block-cipher + block-cipher
0..1 0..1
Message Message
Figure 6.7: Encrypted communications between 2 nanobots
Analysis Ciphering of the communications provided confidentiality for the protocol, even if
the session key is known by every robot across the structure. The hashing of the code in two
parts prevents a leak of credentials during the authentication.
Assuming that the session key is the hashing of the whole code, it would also be the data used
to authenticate. A malicious nanobot could possibly copy this hashed block and authenticate
with another robot of the structure and then decrypt the ciphered data. In this case, even if
something copies the first credential to authenticate with another nanobot, it won’t be able
to understand the communications inside the robot swarm.
112 PROLISEAN
This protocol uses higher capacity than phase 1 and will not fit to use with very low resources.
However, the use of lightweight algorithms combined with this protocol can provide an efficient
solution.
To improve security, the code does not have to be cut into exact parts and the separation
between the first part used for authentication and the second one used for encryption, can be
kept secret by the user. As an example, for a 1 000 lines code, line 1 to 384 will be hashed to
authenticate and line 385 to 1 000 to encrypt.
6.3.2.3/ Version 3: PROLISEAN protocol
Context Hashing the whole code and comparing seem to provide enough security to connect
two robots. However, communicating the same hashed code between thousands of robots that
compound the structure is risky. A malicious robot could get this identity block and give it to
another robot of the structure and thus get access.
For better explanation, the point of view of a single nanobot will be considered, unlike the
two previous ones. The reader will then be able to see a robot belonging to the structure and
an unknown robot trying to communicate or sometimes a more global view of an ensemble of
nanobots.
Phase1: Refined authentication phase There is no need to hash the whole code to provide
high security hashed blocks and few lines are enough. In this context, random numbers cannot
be used as all modules have the same seed and will generate the same random number.
Therefore, the proposed solution is based on using chaotic arithmetic sequence that would
define which lines to hash. The chaotic function chosen in this chapter was based on the
logistic sequence presented in Perrin (2008).
Un = µUn−1 (1 − Un−1 ) (6.1)
where 3.57 < µ < 4 and U0 ∈]0, 1[
The integer n in this solution is the number of authentications the robot had before the current
authentication, thus the robot can save the current Un and will not have to calculate it for
each authentication. This sequence, is known to be chaotic with those parameters. Which
means that it will not tend to fix values or centroid when n → ∞. And as per Perrin (2008), µ
should be greater than 3.57 as the chaos will be set at this point. No oscillation is yet visible,
in the output of the function, and slight variations in the initial population lead to radically
different results. Moreover, as long as µ < 4 the result will be included in [0, 1], it will be
multiplied by the size of the code to know which line to hash and send to the other robot
to authenticate. Due to the hardware specifications of the nano-sized robots the variable n
can not have a huge size, this issue is resolved by applying a modulo N in the iteration count
where N is determined at the conception of the modular robot according to its own hardware
limitations.
The security is not only provided using a chaotic determination of the lines but also by the
choice of the parameters µ, U0 , N that can be changed before the initialization of the structure
by the user itself.
To execute this phase, both nanobots must execute all the actions in the meantime as presented
by Figure 6.8a and the sequence diagram in Figure 6.8b
Nanobot Unknow-bot
Code LinePicker << dataFlow >> LinePicker Code

+ linePicker + linePicker
What iteration of Un
+ Line: String 0..1 0..1 +numberOfAuth: Int +numberOfAuth: Int 0..1 0..1 + Line: String
Hash Function lineToHash lineToHash Hash Function
0..1
0..1
Identity Block + identityBlock Comparison Identity Block
<< dataFlow>>
0..1 + Validation() 0..1 + identityBlock
(a) Phase 1 refined

:Nanobot :UnknownBot
Authentication proposal
Value of "n"
Calculation of U(n) Calculation of U(n)
Determination of lines Determination of lines
Hashing the selected lines Hashing the selected lines
Identity block
Comparison of ID-Blocks
Authentication success/failure
(b) Sequence diagram of the authentication phase in V3
Figure 6.8: Refined version of phase 1
In order to allow robots to know which one must send the authentication request when they
connect, it has been determined that only the one in motion sends an authentication request
to the other. This was set up because a malicious robot could just stick to another robot,
wait for the identity block to be sent to it and then send it back to the same robot resulting
to the hack of the authentication phase. Thus, it is necessary that the robot stationary at the
time of contact is silent and waits to receive the authentication request from the one that just
114 PROLISEAN
connected to it, to counter this flaw.
In case both robots were in motion at the time of contact, both robots would send a request.
If one of them was malicious then it would perform the same scenario as before, waiting for
the identity block to be sent and send it back instantly. The procedure to counter this second
loophole is as follows:
• When sending an authentication request to one of its ports, if the nanobot also receives
a request then the connection via that port will be processed last.
• If connections have been made with other neighbours, then forget the disputed port.
• If no other connection, send back an authentication request.
If the robot is malicious, it will have to send a request again, get back to the initial authen-
tication case and will be a refused authentication. Figure 6.9 illustrates the procedure to be
adopted in the above-mentioned case. The blue robot, which knows the protocol, will first
make connections with its other motionless neighbours and then, acknowledging that it is con-
nected, waits for the red robot to send a second request. Finally, if the red robot belongs to
the structure and is not connected to any other nanobot then it can make its connection with
it like in Figure 6.9a, and if it does not belong to it then it will be blocked according to the
classic authentication phase, Figure 6.9b.
All these conditions had to be set up to prevent a nanobot from being separated from the
structure due to security rules. This is the case in the following illustration, if they both made
the authentication request then any robot could connect. However, if communications were
cut off after a double request then the robot with no connection would be isolated from the
others.
(a) When a friendly robot and a malicious robot are in movement at the same time, the friendly robot
finished authentication with the modules that are were not in movement. Then tries to authenticate
the malicious robot, since the malicious robots does not know the protocol it will not be authenticated.
(b) When two friendly robot are in movement at the same time, each module finishes the authentication
with the modules that were not in movement then authenticates the moving module.
Figure 6.9: Conflict resolution in three steps against a malicious robot (a) and with a friendly
robot (b). Blue modules represent a friendly robot in movement. Red modules represent
malicious modules. The desired new place of a module is depicted by dotted module and a
dashed arrow. When messages are authenticated, they are represented by thick blue arrows or
thick red arrows if otherwise. The blue Shields represent a secured interface.
Phase 2: Ciphered communication with multiple keys The second phase considers that
the encryption key is unique per couple of nanobots. In this configuration, each couple of
nanobots confirmed that the identity block was the same for both and therefore it is used as a
session key to encrypt data between both. A robot will have to save up to four or six session
keys at the time and delete it to save memory space once the communication is over.
One of the conditions for using symmetric encryption is that the public key is known only by
116 PROLISEAN
a small controlled number of entities. Ideally, if only the two entities in communication have
this key, it is called a session key. In this case it is created by the two nanobots, compared and
used, as one would use a session key in a traditional way of such an algorithm.
In this scenario, it is highly unlikely that three nanobots would have the same encryption key to
perform two communications; i.e IDA−B = IDB−C ; In order to avoid any unpleasant surprises,
it is recommended in this protocol to delete the encryption keys when the communication is
over and to set a sufficiently large n, where n is the number of authentications the robot
had before the current authentication. Indeed, one of the situations where this could happen
would be a communication in A and B that would last long enough for B to make N other
communications when a C robot requests authentication and produces the same key.
Figure 6.10 presents the functional scheme of this phase.
Nanobot A
ID Block A-B
Message
+ Key: String
0..1 0..1
0..1
+ block-Cipher Nanobot B ID Block A-B
Block-Cipher
+Block-Cipher + Key: String
0..1 + Encryption() + blockCipher 0..1
+ Decryption() Gate
<< Data Flow >> A-B 0..1
Ciphered Data Block-Cipher
+ message Message
+ Encryption() 0..1 0..1
Nanobot C << Data Flow >> + Decryption()
ID Block B-C Ciphered Data
Message Gate 0..1
B-C + blockCipher 0..1
+ Key: String
0..1 0..1 ID Block A-B
+ block-Cipher 0..1 + Key: String
Block-Cipher
+Block-Cipher
0..1 + Encryption()
+ Decryption()
Figure 6.10: Functional scheme of the ciphered communications during the second phase
Analysis This stage of the protocol is heavier than the previous versions but safe. The way
it uses the chaotic sequence, the logistic sequence, offers three configurable parameters. Once
combined with the use of a hash function and a block cipher, the parameters offer a very strong
security system. Moreover, if the unknown-bots were trying to penetrate the structure, the only
data they will receive is the value of n that is permanently changing with the authentications
on the other hubs of the nanobots and the refusal of the authentication. Thus, no data leaks
from the structure to this intruder. Like the others, it was designed to be light for low resources
swarm of robots by the use of a simple arithmetic sequence and its own lines of code as keys.
Figure 6.11, summarizes every possible interaction a robot and its neighbours could have by
following this protocol.
Nanobot E ID Block A-B Nanobot B
Message + Key: String Hash Function

Nanobot A
0..1 0..1
0..1 ID Block A-E ID Block A-D ID Block A-B ID Block A-C Code
+ block-Cipher
0..1
Block-Cipher + Key: String + Key: String + Key: String + Key: String + hashFunction 0..1
+Block-Cipher 0..1 0..1 0..1 << dataFlow >>
0..1
ID Block B-A
+ block-Cipher 0..1
0..1 + Encryption() + block-Cipher + code
+ Decryption() dataFlow Gate 0..1 0..1 id-Block-A-B + comparison LinePicker
Opening
A-B 0..1
Block-Cipher Gate A-B +numberOfAuth: Int
Comparison 0..1
Hash Function
+ Encryption() 0..1
Gate A- 0..1 + Validation()
Nanobot D dataFlow + Decryption()
ID Block A-B C << dataFlow >>
Gate B- 0..1 What iteration of Un
Message
+ Key: String C
+ message hashFunction
0..1 Nanobot B
0..1 0..1
+ block-Cipher LinePicker
0..1 ID Block A-C
Message Code 0..1
Block-Cipher +numberOfAuth: Int
+Block-Cipher + Key: String
+ Lines: String
0..1 + Encryption() + Un()
+ Decryption()
Figure 6.11: Neighbours interactions following the version three of the protocol
Since the nanobots will have to handle up to six communications at the same time with multiple
authentications and disconnections if the structure is in movement, the protocol may cause
latency or consumes more time than if there were no security at all. However, this will not
be such an issue since the miniaturisation of technologies is going deeper every year and nano
scaled processors will soon be able to run this protocol. One can also notice that if all those
protocols and algorithms are embedded during the conception of the nano-modular robots, the
rest of the code can be modified to fit with this way of communicating and reduce the latency.
6.3.2.4/ Version 4: Improved PROLISEAN protocol
Context In the previous version, the fixed module is the one that is asking the moving particle
for authentication. The problem occurs when two moving modules get connected at the same
time. Then they will both be waiting for the other module to authenticate, and this will lead
to an infinite wait time. Thus, a logical disconnection between the two subjects. This section
of the chapter will be proposing a different approach based on the leader election process. At
the end of the leader election, the leader is a root of a spanning tree. Using the depth first
approach, the leader can send an identification message that will give different ID’s for each
module. The identification generated will be referred to as ID Assaker et al. (2020).
Authentication phase At the time of connection, both modules will exchange the following
information: the ID given by the leader, their clock and a hashed part of their code. Module
A will be receiving IDB , CLOCKB and HB (CodeB ). On the other hand, module B will be
receiving IDA , CLOCKA and HA (CodeA ). When module A receives IDB and CLOCKB ,
it will know what part of the code was hashed. Using its hashing function, it will hash the
designated part of the code and will obtain HA (CodeB ),then compare it with the received
118 PROLISEAN
HB (CodeB ). If both hashing results are the same, then the modules are authentic and they
will trigger the next phase of the protocol that is the encryption.
Two main conditions might occur in such a scenario. The first one is when the end user wants
to intentionally merge two different structures to become one system, and the other case is
when an intruder tries to connect to the swarm. When the first case occurs, there is a high
risk that both modules can have the same ID, this is when the CLOCK value is taken into
consideration. This value, with the ID, will be used to define what line of code is used to
retrieve the hashed value.
If an intruder module connects and tries to reply back with the same hashed value and the
same ID and CLOCK, the other module will definitely reject the reply. This is related to
the fact that modules of the same system cannot have the same ID due to the depth first
method used by the leader to provide identifications for the modules. Furthermore, modules
from different systems can not have the same CLOCK. Figure 6.12 shows in depth the
modules, the classes and the function used to achieve phase 1 of version 4.
Nanobot Nanobot 0..1 ID

>
Hash Function
w>
Code Comparison
Flo
+ identiﬁcation
ta
+ Line: String
Da
+ Validation()
<<
lineToHash Clock
0..1 0..1 0..1
+ linePicker 0..1 + internalClock
LinePicker
+ linePicker
0..1 0..1
0..1 0..1 0..1 0..1
+ linePicker LinePicker 0..1
+ identiﬁcation
ID
+ linePicker
0..1 lineToHash 0..1
0..1
>
w>
Comparison Code
Hash Function
Flo
+ internalClock
ta
+ Validation() + Line: String

Da
Clock
<<
0..1
Figure 6.12: Phase 1 of version 4
To execute this phase properly, both nanobots must execute all the actions in the meantime
as presented by the sequence diagram in Figure 6.13.
:Nanobot A :UnknownBot B
Authentication proposal
IDA, clockA, HA(codeA)
IDB, clockB, HB(codeB)

Calculate HB(codeA)
Calculate HA(codeB)
Compare HB(codeA)
with HA(codeA)
Compare HA(codeB)
with HB(codeB)
Authentication success/failure
Figure 6.13: Sequence diagram of the authentication phase in V4
As described in Piranda et al. (2013), before a module accomplishes its movement, its current
neighbour will be sending the new neighbour a message informing it that there is a new module
in movement that is coming to connect. A different approach of the authentication can then
be introduced when particles are moving. The diagram of Figure 6.14 shows and explains how
authentication happens when a modules is in movement.
120 PROLISEAN
1 2
A A A A
B C B C
3 4
A A
B C B C
Figure 6.14: Authentication approach when modules are moving and connecting to new neigh-
bours: 1) When A decides to move and connect to C, it will inform B about its movement and
sends its ID with the message; 2) B, by its turn, will inform C that A is coming to connect to it
and forwards A’s ID as well; 3) Whenever A accomplishes its movement, it will input its ID into
the chaotic function and sends the result obtained to C; 4) C will input the obtained ID from
B, process it in the chaotic function and compares the results. If both results are matching,
then the connection authenticated; The new position of module A is depicted by the dotted
module. The dashed arrow represents the movement that will be made by A. Yellow arrows
means a normal communication and message exchange. Red arrow means that the module is
asking for authentication and green arrow depicts the approval of the authentication
Encrypted Communication The encryption method used in version three can be used here
since it is safe and secure.
Analysis The use of both chaotic function and identifications generated by the leader helps
making the system even more secure. Such approach requires more computational power than
the previously described versions. The person creating the system is the only one who is aware
of the computational power and its modules. Therefore, the end user is left with the decision
of what version to choose.
6.3.3/ Analysis
6.3.3.1/ Limits of the method
The goal is to create an authentication method that has the least possible impact on the
functioning of the whole system. It was necessary to find a method using the minimum of
resources. Most of the limitations of the proposed protocol come from the environment in
which the experiment takes place. Nothing has yet clearly defined what motivates robots to
move in a certain way. This knowledge might be useful to design a lighter protocol.
From a more conceptual point of view, energy supply is not yet defined either. Some researchers
would like to be able to supply energy via the static electricity that surrounds the material.
However, others are looking to create nanoscopic batteries. This would make it possible to
define the individual energy consumption of each robot and know whether the application of
such a protocol does consume too much energy at the macroscopic level. Not to mention the
fact that the only thing known about the hardware capabilities of the modules is that they are
very limited. In order to be able to properly dimension this protocol, it will be necessary to
know the memory card size, the CPU speed, the transmission rate between robots, and many
other metrics.
6.3.3.2/ Security assessment according to CIA criteria
ISO/CEI 27001 is a norm that defines security standards for IT field. Among all its content, 6
criteria can be found to assess and classify security algorithms and protocols. This upcoming
section focuses on the following four: Confidentiality, Integrity, Authentication and Availability.
Each one will be defined and discuss through the 4 versions of PROLISEAN. The remaining
criteria are:
• Traceability, which is inexistent in this protocol because of the low hardware capacities.
• Attributability, where each entity in this protocol is responsible of one action. In this
protocol, it is the case in each version. Thus, it does not allow an assessment.
Integrity The use of the hashing technique based on considering some lines of code provides
integrity to the system. Moreover, the use of chaotic hashing function will prevent adversary
robot to use the same hash code. If the hashed result compared at the receiver side is not the
same, the robot will know that the message was modified during transmission. This provides
integrity of messages, and the robot will ask for the message to be resent.
Confidentiality Version 1 provides a first level of confidentiality by filtering the connections

to the swarm of robots. Moreover, Version 2 enhances the confidentiality by using ciphered
communications that can be only decrypted by the key-owners. Then, in the third version, a
potential intruder is only able to read data from the robot that have been hacked. In the last
version, it is quite impossible for an intruder to communicate with a module.
Authentication Authentication was the main point during the development of PROLISEAN.
It is the ability to guarantee the identity of the users, here it is done by comparing the source
codes – or some lines – of the robots since it is supposed to be the same across the structure.
122 PROLISEAN
As shown previously, versions 1 and 2 are very light over this fact and allow a very fast
authentication. But the result is a low degree of security in the authentication phase. The
second version presents higher security level since the part of the code used to authenticate
can vary according to the initial parameters. The third version is heavy. However, regarding
authentication, the identity block to show is built for each connection.
And finally, the forth version presents the highest level of security. The usage of identifications
generated by the depth first algorithm and its combination with the clock makes authentication
more efficient.
Availability Availability is the guarantee that all the services and resources remains available.
The point here is that the more secure the version is, the more latency can be expected. And the
assessment is inverted compared to the previous points. Moreover, in the third version, some
connections may not happen between two friendly robots in the case of double authentication
request. However, version four fixes this issue with the usage of the identifications.
Graph 6.15 summarizes the CIA criteria for the different versions of the proposed protocol.
Figure 6.15: Self-assessment of the 4 proposed protocols through CEI criteria

6.4. ALGORITHM ANALYSIS AND PROPOSED SOLUTIONS 123
6.4/ Algorithm analysis and proposed solutions
6.4.1/ The block cipher
6.4.1.1/ An efficient block cipher
Lightweight cryptography is a cryptographic algorithm or protocol tailored for implementation

in constrained environments including RFID tags, sensors, contact less smart cards, health-care
devices and so on. Lightweight properties are described based on target platforms. In hardware
implementations, chip size and/or energy consumption are the important measures to evaluate
the lightweight properties. In software implementations, the smaller code and/or RAM size are
preferable for the lightweight applications Bhardwaj et al. (2017).
Considering the previous results, the focus is on the 5 lightest algorithms: TEA, KTAN,
SEA, HIGHT, and NOEK. Ideally, this latter must have the lowest RAM, energy and memory
consumption but also be fast to encrypt and decrypt. One thing that is noticed during this
part of the study is that the lower the size is, the higher the energy consumption will be.
Indeed, an algorithm with few lines of code written in memory will repeat its functions more
to encrypt with a high security level than a big algorithm with all features in its code. So, the
most efficient one should be chosen.
Collision risk There is a probability that from two different data blocks the same hash result
is obtained, this is called the risk of collision, it is expressed by hash functions designers as
a probability. According to modern cyber security standards, this probability is very low but
n
not zero. For example, for SHA3 it is estimated that a collision can occur at most every 2 2
hashes, with n the output size of the blocks in bits.
Here, all the versions of this protocol rely on the result of a hash function for the authentication
between two nanobots. There is, therefore, a risk that a communication may be authorized
while the two parties do not belong to the same structure and consequently a risk of intrusion
in the event of an attack by someone malicious. Moreover, this probability is not applied to a
single robot but to all the robots in the structure and since their theoretical size is in the order
of nano meter, even a structure with a volume of 1 cm3 could contain thousands of billions of
nanobots. This risk is therefore not to be underestimated.
However, several points prove the use of a hash function for authentication remains a possible
solution:
• With a hashing block size of 128 bits the risk is 1 in 18 billions and with 256-bit blocks
it is 1 in 3.4 × 1038 for a collision to happen.
• The only version of this protocol that relies on the hash function has been created to
prevent two distinct structures from associating. And occasionally, to prevent deliberate
124 PROLISEAN
intrusion by a malicious entity but not controlled by an external user who may understand
the authentication mechanism. Thus, for the objective that was set, the hash function
fulfils, at least in theory, its role. If, during a collision between two structures, a tiny
fraction of the robots, in the order of 1 out of billions mix together, the structures will
be able to continue to perform their initial tasks without difficulty.
• The protocols use block encryption. So the session key is only known by nanobots
belonging to the same structure. Even if an intruder manages to connect, it will be
impossible for him to interpret the communications because it must have the encryption
key. In some models, it will also be necessary for this malicious nanobot to be able to
connect to at least one second robot in the structure to intercept the data flow through it.
Otherwise, it will be considered as one end and will only receive part of the information.
Which drastically reduces the probability of interception of the data.
Memory use This study focused on symmetric encryption to use the minimum number of
keys possible. Using an asymmetric encryption appeared to be a more secured solution but
it included the use of a directory containing millions of public keys. A solution to this issue
could have been to create groups of robots with a common public key. The bigger the groups,
the lower the security. That is why the lines of the robot’s code are used as session key in the
stages 2,3 and 4. Especially in the stage 3 and 4 in which keys are created in a chaotic way
that allows both robots to communicate with a unique session key that is delete at the end of
the communication.
Using the code of the robot in the encryption process also allow to save memory space. Indeed,
there is no need to add lines of code such as registers for the encryption keys. Hash function
provide blocks with a maximum size of 256 bits that is saved in the robots memory, multiplied
by 6 communication ports it gives 1,536 bits of keys or 192 Bytes.
The diagram in Figure 6.16 is based on the figures of ECRYPT II (European Network of
Excellence in Cryptology II) Francois-Xavier Standaert et al. (2010) and compares the cycle
count for encryption and decryption of the 5 algorithms and the energy consumption for
encryption. All those experimental figures were obtained by encrypting a maximum sized block
of data for each algorithm.
Figure 6.16: Crossed analysis of ECRYPT II figures
• KTAN and SEA: The result was quite predictable regarding the size of both implemen-
tations. The number of cycles is twice higher than HIGHT or NOEK based implementa-
tions. For example, the AES based lightweight algorithm tested in ECRYPT II uses 18
time less cycles with the biggest code size of this report.
• TEA: As the energy consumption seems to be proportional with the number of cycles,
the energy needed to decrypt the TEA-based algorithm will be one of the highest among
the others.
• HIGHT and NOEK: Both seem to be a good compromise regarding all the parame-
ters previously introduced. Since HIGHT algorithm has less complexity, therefore, this
algorithm will be the focus of this chapter.
6.4.1.2/ HIGHT lightweight encryption algorithm
HIGHT for High Security and light weight is a block cipher designed for low resources devices
with 64-bit block length and 128-bit key length for 8-bit processors. It was created to secure
RFID tags that are used in contactless credit cards. Those devices are very interesting in this
study since it presents the same requirement as nano-modular robots which are low hardware
resources and low energy consumption.
It uses a Feistel-like 32-round iterative structure 6.17 that can either be hardware implemented
or software implemented Hong et al. (2006). According to the authors, this algorithm is more
efficient in hardware implemented version since Feistel structure uses XOR logical gates and
additions. HIGHT mostly uses mod 28 additions, XORs and circular shifts of bits. It is also
faster than AES-128 once embedded in a 8-bit processor and lighter in the same time by the use
of only one 128-bit register in the key schedule algorithm for both encryption and decryption
since it contains the 2 master keys values necessary for those operations.
126 PROLISEAN
PlainText Master Key
WK3,WK2,WK1,WK0
Initial Transform
SK3,SK2,SK1,SK0
Round1
Key Schedule
SK127,SK126,SK125,SK124
Round32
WK7,WK6,WK5,WK4
Final Transform
Master Key
CipherText
Figure 6.17: Encryption process of HIGHT Shirai et al. (2007)
This algorithm has proven through different studies Francois-Xavier Standaert et al. (2010);
Hong et al. (2006) its high resistance against all kind of known attacks to be considered as
resistant as classic symmetric block ciphers. To go into more detail, the initial transformation
prepares the data to be processed in the rounds by concatenating the W K3,2,1,0 whitening keys
and the data to be encrypted in the form of a matrix whose coefficients are bit lists. Then the
method called Round is applied 32 times to this matrix. A Round consists of 5 operations on
the rows and columns of the matrix comparable in some way to the precise and known mixing
of a Rubik’s cube. These 5 operations include the following:
• An exchange of the coefficients of this matrix.
• Two XOR operations between the coefficients and the Subkeys SK0,...,128 .
• Two bits additions modulo 28
Once the 32 laps have been completed, the resulting matrix is finally transformed by the
Final Transform function, which undoes the last two operations of the 32nd lap and then
concatenates the entire matrix into a bit string that can be interpreted by the computers as a
character string.
6.4.2/ The Hash function
Considering Figure 6.1 the focus will be on the SPONGENT hash function family which are
lightweight hash functions based on the sponge functions model. A sponge function is often
used in hashing but not only, this term defines functions able to take as a parameter any size
of data and provide a fixed size block in return.
It is advantageous to use such function in this study since the source code of the robot should
be hashed which size is variable. Then use it later as a 128-bit key for one of the symmetric
block cipher.
Those Hash functions are based on the working principle of another lightweight block cipher
called PRESENT. The latter is tested in ECRYPT II report Francois-Xavier Standaert et al.
(2010) but the results of the use of this algorithm to cipher communications was not efficient
for the use of this study. Nevertheless, SPONGENT hash functions that are using its design
principles and are the lightest presented in Francois-Xavier Standaert et al. (2010) in term of
memory size and also RAM capacity use that is the reason why this report is focusing on it.
According to the creators Bogdanov et al. (2011), those hash functions were engineered from
the very beginning to be embedded in small sensors networks such as RFID. It uses a smart
management of the data generated during the hashing process by stocking the least bits possible
during the hashing and serializing the implementation to the point that the logic part of the
function is much smaller that the state part.
The function, like HIGHT, also uses logical gate to optimize the ratio size/RAM use and even
if we could implement it to artificially use those gates. It would ruin the creators efforts to
make it light.
The SPONGENT version would be more likely to be used is the 128-bit one since the 2 previ-
ously introduced block ciphers needs a 128 bits key to work. This version needs 1,060 logical
gates to work in its original design Bogdanov et al. (2011). In this case, logical gates should
also be used to make optimal use of this function. According to the various documents pre-
viously mentioned Bhardwaj et al. (2017); Katagi et al. (2008); Francois-Xavier Standaert
et al. (2010); Bogdanov et al. (2011), it would seem, so far, very complicated to make a hash
function with a small size and a small processor footprint without using it.
128 PROLISEAN
mi mi
f1 f4
hi-1 hi hi-1 hi
mi mi
f2 f5
hi-1 hi hi-1 hi
mi mi
f3
f6
hi-1 hi hi-1 hi
Figure 6.18: Six different ways to turn a block cipher to a hash function Black et al. (2002). M
is the block of data to hash that has been divided into the parts noted mi; hi is the result of a
hash turn, h0 is a constant arbitrarily chosen and the central block is the encryption algorithm.
The latter is used i times based on one of the models
6.4.3/ Proposed Hashing function
To improve the the protocol, the encryption algorithm will be using both hashing function and
encryption such as suggested by Preneel, Govaerts and Vandewall in Preneel et al. (1993). The
challenge was to find a way to use a block cipher that would be secured enough, designed to
be embedded in low capacity devices and be able to run as a hash function within the addition
of a few lines of code.
It is the final stage to create a safe, hardly breakable and lightweight system to secure nano-
modular robots structures. All the security of the structure will fit into a small algorithm able
to encrypt, decrypt and hash on demand and with high security standards.
This method was very interesting in the past. The first hash functions were created by modify-
ing DES for instance, and then, with the increase of the threat in cybersecurity those functions
could not handle the high security requirement. Finally, with the arrival of AES standard the
interest for it pop-up back in the scientist landscape to the point that now, a lot of work about
this topic is available. For now, only heavy algorithms have been turned into hash function
successfully in terms of security standards respect and it would be a great challenge to create
such versatile algorithm.
There are 64 ways to turn a block cipher into a hash function, Figure 6.18 introduces 6
examples, among them few can handle the international security standards. For a simple
reason, ciphers are created to encrypt and decrypt but not hash functions. That is why,
6.5. SIMULATION AND DIFFERENTIAL CRYPTANALYSIS 129
encryption keys are considered weak in the hashing standards.
Nevertheless, the idea is relatively simple in the design because it is necessary to find a way
to use the encryption algorithm that makes it almost indecipherable but not due to chance.
Indeed, for the same block of data, a hash function must return the same block.
As previously mentioned, this solution appears to be the most convincing among all because of
the simplicity to implement, the resistance against known attacks and the low memory space
required. Furthermore, Katagi et al. (2008); Rogaway et al. (2008) are dealing with a Noekeon
based hash function with the addition of a few code lines. It might be interesting to integrate
block encryption and hash function from Noekeon. Indeed, according to Katagi et al. (2008),
the Noekeon-based hash function is heavier than SPONGENT during its operation and also
in the memory space. As most of the code lines of the latter would already be written in the
source code of the robots with the block cipher, then it results that by using the NOEKEON-
based hash function this only adds a few more lines in the code. The diagram in Figure 6.19
shows how an encryption algorithm can be used for hashing as well, thus reducing the memory
and processing usage.
Yes
HEIGH Hash? %
No
Figure 6.19: Using the HEIGH algorithm for encryption and hashing simultaneously
Total Total Total decrypt time decrypt time decrypt time decrypt time
Method P (Ek (m) = c)
Rounds Plain Text Encryption 64b in year 32b in year 16b in year 8b in seconds
Differential 2−58 11+ 2248 NA 7.17 ∗ 1049 1.55 ∗ 1031 3.37 ∗ 1012 20
Linear 2−54 10 2228 NA 6.83 ∗ 1043 4.74 ∗ 1026 3.29 ∗ 1009 0.7
Impossible Diff. NA 8 293.6 2109.2 5.71 ∗ 1032 2.33 ∗ 1018 9.51 ∗ 103 0.001
Saturation NA 16 2168 251 5.93 ∗ 1025 1.35 ∗ 1013 3.06 2.19 ∗ 10−5
Boomerang NA 13 2248 NA 7.17 ∗ 1049 1.55 ∗ 1031 3.37 ∗ 1012 20
Table 6.3: Cryptanalysis results for the HIGHT algorithm
6.5/ Simulation and differential cryptanalysis
6.5.1/ Simulations
A simulation was done using VisibleSim in order to implement and evaluate the protocol. In
this scenario, a task is a message send or received. Table 6.4 shows all type of messages that
are being exchanged in the system.
In this simulation, three modules are placed. One of the modules is the main robot in the
130 PROLISEAN
H]
Message Type Message Description
AUTH REQUEST MSG This message is sent by a module that is requesting authentication to connect
AUTH GRANTED MSG Once this message is sent, it means that the module is authenticated to connect
AUTH REJECTED MSG Once this message is sent, it means that the module is not authenticated to connect and the connection will be blocked
Table 6.4: Different messages type
initial system. The other two are placed in a way that one is authentic and the other one is not.
Figure 6.20 shows in details the messages exchanged among the modules in order to approve
or reject the connected robot. Furthermore, table 6.5 shows and explains the real values
during the simulation. The columns Value1 and Value2 represents the values of the variables
with index 1 and 2 respectively. Moreover, Figure 6.21 presents the structures simulated on
VisibleSim.
Request authentication Request authentication
1 c1 i1 h1 c2 i2 h2
2
c1 i1 => chaos1 c2 i2 => chaos2
chaos1 => linePicker1 chaos2 => linePicker2
linePicker1 => h'1 linePicker2 => h'2
h1 == h'1 h2 == h'2
true false
1 2
Figure 6.20: Simulation graph. The initial module is colored in yellow. The bots that are trying
to authenticate are in white and numbered 1 and 2. After the authentication phase, module
1 is authenticated, therefore, it is now colored in yellow. Module 2 in rejected, therefore it is
colored in red.
Variable Definition Value1 Value2

c Clock 1598048073 1598048068
i Iteration 17 20
h Hashed value 6652819590941555539 17788932521966903233
Is the value generated by the
chaos 47 46
chaotic function based on c and i
linePicker Is the line picked based on the value of chaos year joke
h’ The hashed result by the authenticating bot 6652819590941555539 13758745852358344340
Table 6.5: Variables used in the simulation and their values

6.5. SIMULATION AND DIFFERENTIAL CRYPTANALYSIS 131
(a) This is the initial state of the system. (b) The first bot in the system is colored in yellow
(c) This is the initial state of the system. (d) Three spanning trees. The green and blue trees
are identical.
Figure 6.21: Comparison of two cases, a) and b) has the same blue and green trees but b) has
yellow modules in addition. In the case b), yellow tree will dramatically change the results.
The yellow tree will be loosing against the blue tree, and it will be then merged into one tree.
So in this case having two identical trees is not considered as a collision.
6.5.2/ Differential cryptanalysis
In Hong et al. (2006), the authors provided the security analysis and statistical randomness
tests of HIGHT against multiple types of attacks. Table 6.3 summarizes the analysis results.
Those tests were made on an 8-bit key lengths to be able to reverse the encryption in a
timely manner. Whereas the key length used in this scenario is a 64 bits key. The fastest
decryption process was the linear cryptanalysis. The number of plain texts needed to reverse
the encryption on an 8 bit key was 257 . When using the 64 bit key, the number of plain texts
needed will be (257 )4 = 2228 . As long as the modules are changing their key at least every 227
times they send a message, the encryption will remain safe. In this scenario, it is suggested to
change the key used every 2 or 3 times the module sends a message.
The fastest supercomputer McCorkle (2020), called Summit, can make 200 ∗ 1015 calculations
per seconds. Using this value and the differential cryptanalysis method, the values in Table
6.3 are calculated. It is then obvious that 16bit key length for HIGHT encryption is more than
132 PROLISEAN
enough to secure the encryption and make it impossible to decrypt it in a timely manner.
6.6/ Conclusion
This chapter presents the design and implementation of the first security protocol for pro-
grammable matters based on nano modular robots. It describes a solution that avoids intrusion,
whether physically by a foreign nanobot or logically by an external hardware. The protocol is
derived in four versions in order to adapt to the capacity of the matter and to the needs of a
potential user. It describes and uses optimal lightweight cryptography and hashing algorithms
from the perspective of space/time complexity and energy consumption. Moreover, a chaotic
arithmetic sequence was applied to the source code of the robots, at each hashing time slot,
to avoid Trojan attacks. Finally, the protocol is implemented on VisibleSim and evaluated.
Results show that 16 bit key length for HIGHT encryption is enough to secure the system.
7
Conclusion
133
134 Conclusion
his dissertation offered unique techniques for resolving typical difficulties in modular robots.
T These methods will enable scientists to develop matter that can be designed to master its
surroundings. Based on the data collected, this substance can adapt to its surroundings and
modify its configuration. This is a small element of a much larger project being undertaken by
scholars all across the world. The primary goal is to move beyond 3D models by adding a fourth
dimension to things. This will allow us to perceive models and interact with data in entirely new
ways. Because programmable matter has restrictions such as physical ability, communication,
restricted memory, limited computing power, and clock synchronization, each typical method
becomes a very difficult challenge. While researchers have previously focused on the problem,
we argue in this thesis that a fundamental shift in approach or underlying assumptions in leader
election, self-reconfiguration, fault detection, and security can be achieved by improving how
modular robots are defined and considering a different set of assumptions about the problems.
As a result, we suggest an important structure and several algorithms for implementing those
novel approaches, and we demonstrate that current findings support the theory.
A novel method for selecting a leader for a modular robotic system was described. This method
is deterministic and is based on the creation of a spanning forest. Each tree in this forest begins
with a potential leader. Once the trees are created, they will compete with one another until
only one tree remains. The benefits of employing this algorithm include its ability to run on
lattice-based modular robots regardless of their original configuration and was tested only on
Blinky Blocks . It is capable of running on both 2D and 3D platforms. This six-phase method
operates in linear space and time. In some unusual setups, the algorithm elects numerous
leaders. An in-depth investigation of the configurations that result in a termination with no
leader is offered, which can aid in the prevention of similar situations in the future.
An advanced probability analysis can also be explored to better comprehend the algorithm’s
success rate. Finally, a theoretical research on the impact of delays on algorithm execution
could be presented, and the parameters could be varied in relation to the network width and
the speed of message transmission in the system.
Following the election of the leader, the system will execute a reconfiguration procedure to
convert into the desired shape. The suggested reconfiguration algorithm is based on Virtual
Force Algorithm (VFA), which was influenced by Wireless sensor network (WSN) systems.
This algorithm employs both distributed and centralized methods. It uses the Kuhn-Munkres
method to fill the majority of the vacant spaces in the objective shape with free modules.
Once the free modules have been relocated to different positions, additional free modules will
become available and will be transferred to the next open position.
In future work, an approach based on the sparsity structure of the cost matrix could be used
to improve the Kuhn-Munkres algorithm. This has the potential to increase the complexity of
our approach. Another potential future option is to investigate a self-reconfiguration method
for 3D lattice modular robots.
Conclusion 135
Once all modules are in place, it is critical to preserve module communication, ergo DETEC-
TOR. DETECTOR is a programmable matter-based hierarchical fault detection technique.
The proposed technique detects partial disconnections by constructing a spanning tree that
extends from the leader to all nodes. The leader now has access to the node’s coordinate. The
program can detect partial disconnection by doing a fast comparison. The simulation results
suggest an increased rate of disconnection detection, particularly in a high density system. The
accuracy of detecting disconnections ranged from 90% to 100%. Furthermore, the simulations
revealed that the algorithm’s complexity in terms of the number of messages exchanged stays
linear.
Future work should include the capacity to detect disconnection during the development of
the spanning tree, to maintain the spanning tree updated throughout robot movement, and
to detect complete disconnections in a modular robotic system. For example, the addition of
alternative modes of communication, such as wireless communication, can aid in the detection
of a complete separation, resulting in the isolation of specific modules from the entire system.
Concerning Blinky Blocks, the main modules used in this thesis, it would be interesting to
study the ability of updating the hardware in the future. If the update shows that the magnets
on one side of a block are active but the module still can’t communicate through this side,
then a disconnection exists.
Finally, and most importantly, there is security. Security was never considered when it came
to programmable matter. Because modular robots can be utilized in sensitive applications, a
security protocol should be implemented. As a result, PROLISEAN, the first security protocol
for modular robotics, was born. Despite the fact that the environment is not well suited to the
implementation of such a protocol, it allows for the proposal of the foundation of a solution to
avoid intrusion into programmable matter. Whether physically through the arrival of a foreign
nanobot or logically through the use of external gear. The latter is generated in four variants
in order to respond to the capacities as well as the needs of a potential user as best as possible.
The chapter highlighted approximately ten block ciphers and hash functions that potentially
fit the requirements of the experiment after classifying the encryption methods by size and
documentation. Then they were ranked by size, energy consumption, and functionality to
highlight the one that could currently be the most effective when merged into the previously
stated protocol. After researching the various methods, it emerges that symmetric encryption
is considerably more energy and capacity efficient than asymmetric encryption. To use it in
both ways, the chosen method would be to create the HIGHT block cipher for communication
encryption and add the few lines necessary to transform it into a hash function. It is a
lightweight algorithm with a low number of cycles during operation. In the future, we will
investigate the overall system’s complexity. In this context, new strategies based on system
clustering must be developed. To improve communication complexity in big scale systems,
the leader election phase can be extended by introducing sub-leaders at different levels. This
element provides numerous issues, ranging from key distribution across levels and sub-leaders
136 Conclusion
to the security strategy that must be implemented in the event of a leader breach. Finally, an
actual implementation that takes into account the leader election, the security protocol, and
the shape formation must be considered.
Modular robots are an exciting area of research and development that have the potential to
revolutionize the field of robotics. Despite the progress that has been made in recent years,
there is still much work that needs to be done in order to fully realize the potential of these
systems.
The field of modular robotics has seen significant advances in recent years, with the devel-
opment of various algorithms and methods for enhancing the performance and robustness of
modular robotic systems. The current dissertation has made a valuable contribution to this
field by presenting four algorithms for distributed modular robots, including a leader election
algorithm, a reconfiguration algorithm using virtual forces, a disconnection detection algo-
rithm, and a security protocol. The proposed algorithms were tested and validated through
simulations and experiments, demonstrating their effectiveness and potential for improving the
performance and robustness of modular robotic systems.
While these algorithms have shown great potential, there is still much room for further im-
provement and extension of the work done in this manuscript. Over the next years, I envision
several promising directions for future work, including enhancing the robustness of the leader
election algorithm in the presence of node failures, integrating the reconfiguration algorithm
with real-time control and sensing systems, developing a more efficient disconnection detec-
tion algorithm, and exploring the application of machine learning techniques for enhancing the
security of modular robotic systems.
Regarding the leader election algorithm, one potential direction for future work is to enhance
its robustness in the presence of node failures. This can be achieved by developing algorithms
that can quickly and effectively detect and recover from node failures, ensuring that the leader
node can continue to coordinate and control the system even in the presence of failures.
Integrating the reconfiguration algorithm with real-time control and sensing systems is another
promising direction for future work. This can enable modular robots to make informed decisions
about their reconfigurations based on real-time sensory information, resulting in more efficient
and effective reconfigurations. For example, modular robots can use real-time information
about the environment to determine the optimal configuration for a given task.
The disconnection detection algorithm can also be improved by developing a more efficient
algorithm that can detect and diagnose disconnections in real-time, even as the system is mov-
ing. This can be achieved by integrating alternative modes of communication, such as wireless
communication, into the system, enabling the system to detect complete disconnections even
in the presence of movements and vibrations. Additionally, the hardware of the main modules
used in this thesis, the Blinky Blocks, could be updated to improve the ability of the system
Conclusion 137
to detect disconnections.
Finally, exploring the application of machine learning techniques for enhancing the security of
modular robotic systems is a promising direction for future work. This can enable modular
robots to learn from previous experiences and improve their security protocols over time, making
them more resistant to security threats. For example, modular robots can learn to recognize
and respond to potential security threats, such as unauthorized access attempts, in real-time.
In conclusion, the work presented in this dissertation represents a significant step forward in
the field of modular robotics, with the potential to inspire further research and development
in this exciting and rapidly evolving field. By exploring the promising directions for future
work outlined above, I believe that we can continue to advance the state-of-the-art in modular
robotics and enable new and exciting applications in a wide range of domains.
Personal Publications
Hourany, E., Habib, B., Fountaine, C., Makhoul, A., Piranda, B., et Bourgeois, J. (2021a).
Prolisean: A new security protocol for programmable matter. ACM Transactions on
Internet Technology (TOIT), 21(1):1–29.
Hourany, E., Piranda, B., Makhoul, A., Bourgeois, J., et Habib, B. (2022). Detector: Hi-
erarchical distributed fault detection algorithm for lattice based modular robots.
In International Conference on Advanced Information Networking and Applications, pages
118–129. Springer.
Hourany, E., Stephan, C., Makhoul, A., Piranda, B., Habib, B., et Bourgeois, J. (2021b). Self-
reconfiguration of modular robots using virtual forces. In 2021 IEEE/RSJ International
Conference on Intelligent Robots and Systems (IROS), pages 6948–6953. IEEE.
139
Bibliography
Ahmad, S., Zhang, H., et Liu, G. (2013). Distributed fault detection for modular and
reconfigurable robots with joint torque sensing: A prediction error based approach.
Mechatronics, 23(6):607–616.
Ahmadzadeh, H., et Masehian, E. (2015). Modular robotic systems: Methods and algo-
rithms for abstraction, planning, control, and synchronization. Artificial Intelligence,
223:27–64.
Ahmadzadeh, H., Masehian, E., et Asadpour, M. (2016). Modular robotic systems: Char-
acteristics and applications. Journal of Intelligent & Robotic Systems, 81(3):317–357.
Andreev, V., et Pletenev, P. (2019). Organizing network interaction in modular robot

with multilevel control system. Annals of DAAAM & Proceedings, 2020, 30.
Andrés Arroyo, M., Cannon, S., Daymude, J. J., Randall, D., et Richa, A. W. (2018). A
stochastic approach to shortcut bridging in programmable matter. Natural Computing,
17(4):723–741.
ANSSI (2010). La mÉthode ebios risk manager.
Arış, A., Oktuğ, S. F., et Yalçın, S. B. Ö. (2015). Internet-of-things security: Denial
of service attacks. In 2015 23nd Signal Processing and Communications Applications
Conference (SIU), pages 903–906. IEEE.
Asadpour, M., Ashtiani, M. H. Z., Sproewitz, A., et Ijspeert, A. (2009). Graph sig-
nature for self-reconfiguration planning of modules with symmetry. In 2009
IEEE/RSJ International Conference on Intelligent Robots and Systems, pages 5295–5300,
doi: 10.1109/IROS.2009.5353943.
Ashley-Rollman, M. P., De Rosa, M., Srinivasa, S. S., Pillai, P., Goldstein, S. C., et Campbell,
J. (2007a). Declarative programming for modular robots.
Ashley-Rollman, M. P., Goldstein, S. C., Lee, P., Mowry, T. C., et Pillai, P. (2007b). Meld:
A declarative approach to programming ensembles. In 2007 IEEE/RSJ International
Conference on Intelligent Robots and Systems, pages 2794–2800. IEEE.
Assaker, J., Makhoul, A., Bourgeois1, J., et Demerjian, J. (2020). A unique identifier
assignment method for distributed modular robots. In 2020 IEEE/RSJ International
Conference on Intelligent Robots and Systems, IROS 2020. IEEE.
141
142 BIBLIOGRAPHY
Baca, J., Ferre, M., et Aracil, R. (2012). A heterogeneous modular robotic design for
fast response to a diversity of tasks. Robotics and Autonomous Systems, 60(4):522–531,
doi: https://doi.org/10.1016/j.robot.2011.11.013.
Bahi, J. M., Guyeux, C., et Makhoul, A. (2010). Secure data aggregation in wireless sensor
networks: homomorphism versus watermarking approach. In International Conference
on Ad Hoc Networks, pages 344–358. Springer.
Bassil, J., Moussa, M., Makhoul, A., Piranda, B., et Bourgeois, J. (2020). Linear distributed
clustering algorithm for modular robots based programmable matter. In IEEE/RSJ
International Conference on Intelligent Robots and Systems, IROS 2020, Las Vegas, NV,
USA, October 24, 2020 - January 24, 2021, pages 3320–3325. IEEE.
Bazzi, R., et Briones, J. (2018). Brief announcement: Deterministic leader election

in self-organizing particle systems. In Izumi, T., et Kuznetsov, P., editors, Stabilization,
Safety, and Security of Distributed Systems - 20th International Symposium, SSS 2018, Pro-
ceedings, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial
Intelligence and Lecture Notes in Bioinformatics), pages 381–386. Springer Verlag.
Bazzi, R. A., et Briones, J. L. (2019). Stationary and deterministic leader election in

self-organizing particle systems. In International Symposium on Stabilizing, Safety, and
Security of Distributed Systems, pages 22–37. Springer.
Bhardwaj, I., Kumar, A., et Bansal, M. (2017). A review on lightweight cryptography

algorithms for data security and authentication in iots. In 2017 4th International
Conference on Signal Processing, Computing and Control (ISPCC), pages 504–509. IEEE.
Biryukov, A., et Perrin, L. P. (2017). State of the art in lightweight symmetric cryptog-
raphy.
Bishop, J., Burden, S., Klavins, E., Kreisberg, R., Malone, W., Napp, N., et Nguyen, T.
(2005a). Programmable parts: a demonstration of the grammatical approach to
self-organization. In 2005 IEEE/RSJ International Conference on Intelligent Robots and
Systems, pages 3684–3691, doi: 10.1109/IROS.2005.1545375.
Bishop, J., Burden, S., Klavins, E., Kreisberg, R., Malone, W., Napp, N., et Nguyen, T.
(2005b). Self-organizing programmable parts. In International Conference on Intelligent
Robots and Systems, pages 3684–3691.
Black, J., Rogaway, P., et Shrimpton, T. (2002). Black-box analysis of the block-cipher-
based hash-function constructions from pgv. In Annual International Cryptology Con-
ference, pages 320–335. Springer.
BIBLIOGRAPHY 143
Bogdanov, A., Knežević, M., Leander, G., Toz, D., Varıcı, K., et Verbauwhede, I. (2011).
Spongent: A lightweight hash function. In International Workshop on Cryptographic
Hardware and Embedded Systems, pages 312–325. Springer.
Bonabeau, E., Theraulaz, G., Dorigo, M., Theraulaz, G., Marco, D. d. R. D. F., et others
(1999). Swarm intelligence: from natural to artificial systems. Number 1. Oxford
university press.
Bourgeois, J., Cao, J., Raynal, M., Dhoutaut, D., Piranda, B., Dedu, E., Mostefaoui, A., et
Mabed, H. (2013). Coordination and computation in distributed intelligent mems. In
2013 IEEE 27th International Conference on Advanced Information Networking and Appli-
cations (AINA), pages 129–136. IEEE.
Bourgeois, J., et Goldstein, S. (2012). Distributed intelligent mems: Progresses and

perspectives. ICT Innovations 2011, pages 15–25.
Brunete, A., Hernando, M., Gambao, E., Torres, J. E., et Castro-González, A. (2011). Mdl: A
module description language for chained heterogeneous modular robots. In 2011 IEEE
International Conference on Robotics and Biomimetics, pages 2706–2711, doi: 10.1109/RO-
BIO.2011.6181714.
Cannon, S., Daymude, J. J., Randall, D., et Richa, A. W. (2016). A markov chain algorithm
for compression in self-organizing particle systems. In Proceedings of the 2016 ACM
Symposium on Principles of Distributed Computing, pages 279–288.
Castano, A., Shen, W.-M., et Will, P. (2000). CONRO: Towards deployable robots
with inter-robots metamorphic capabilities. Autonomous Robots, 8(3):309–324,
doi: 10.1023/A:1008985810481.
Cekerevac, Z., Dvorak, Z., Prigoda, L., et Cekerevac, P. (2017). Internet of things and the
man-in-the-middle attacks–security and economic risks. MEST Journal, 5(2):15–25.
Chen, I.-M., et Burdick, J. W. (1998). Enumerating the non-isomorphic assembly con-

figurations of modular robotic systems. The International Journal of Robotics Research,
17(7):702–719.
Chung, W. K., Han, J., Youm, Y., et Kim, S. (1997). Task based design of modular robot
manipulator using efficient genetic algorithm. In Proceedings of International Conference
on Robotics and Automation, volume 1, pages 507–512. IEEE.
Cui, H., Zhang, J., Cui, C., et Chen, Q. (2016). Solving large-scale assignment problems
by kuhn-munkres algorithm, doi: 10.2991/ameii-16.2016.160.
Dai, J. S., Zoppi, M., Kong, X., et others (2012). Advances in reconfigurable mechanisms
and robots I. Springer.
144 BIBLIOGRAPHY
Davey, J., Kwok, N., et Yim, M. (2012). Emulating self-reconfigurable robots - de-
sign of the SMORES system. In 2012 IEEE/RSJ International Conference on In-
telligent Robots and Systems, pages 4464–4469, Vilamoura-Algarve, Portugal. IEEE,
doi: 10.1109/IROS.2012.6385845.
Daymude, J. J., Derakhshandeh, Z., Gmyr, R., Porter, A., Richa, A. W., Scheideler, C., et
Strothmann, T. (2018). On the runtime of universal coating for programmable matter.
Natural Computing, 17(1):81–96.
Daymude, J. J., Gmyr, R., Richa, A. W., Scheideler, C., et Strothmann, T. (2017). Leader
election with high probability for self-organizing programmable matter. CoRR,
abs/1701.03616, 2017.
Daymude, J. J., Hinnenthal, K., Richa, A. W., et Scheideler, C. (2019). Computing by

programmable particles. In Distributed computing by mobile entities, pages 615–681.
Springer.
Daymude, J. J., Richa, A. W., et Weber, J. W. (2021). Bio-inspired energy distribution

for programmable matter. In International Conference on Distributed Computing and
Networking 2021, pages 86–95.
De Rosa, M., Goldstein, S., Lee, P., Campbell, J., et Pillai, P. (2006). Scalable shape
sculpting via hole motion: Motion planning in lattice-constrained modular robots.
In Robotics and Automation, 2006. ICRA 2006. Proceedings 2006 IEEE International Con-
ference on, pages 1462–1468. IEEE.
Derakhshandeh, Z. (2017). Algorithmic Foundations of Self-Organizing Programmable

Matter. PhD thesis, Arizona State University.
Derakhshandeh, Z., Dolev, S., Gmyr, R., Richa, A. W., Scheideler, C., et Strothmann, T.
(2014a). Amoebot-a new model for programmable matter. In Proceedings of the 26th
ACM Symposium on Parallelism in Algorithms and Architectures, pages 220–222.
Derakhshandeh, Z., Gmyr, R., Richa, A. W., Scheideler, C., et Strothmann, T. (2016). Uni-
versal shape formation for programmable matter. In Proceedings of the 28th ACM
Symposium on Parallelism in Algorithms and Architectures, pages 289–299.
Derakhshandeh, Z., Gmyr, R., Richa, A. W., Scheideler, C., et Strothmann, T. (2017). Uni-
versal coating for programmable matter. Theoretical Computer Science, 671:56–68.
Derakhshandeh, Z., Gmyr, R., Richa, A. W., Scheideler, C., Strothmann, T., et Tzur-David, S.
(2014b). Infinite object coating in the amoebot model. arXiv preprint arXiv:1411.2356.
Devi, N. R., Uma, G., Praveena, T., et Jyothi, M. N. (2013). Emerging and challenging
applications in swarm robotics. Int J Eng Sci, 2:318–321.
BIBLIOGRAPHY 145
Dewey, D. J., Ashley-Rollman, M. P., Rosa, M. D., Goldstein, S. C., Mowry, T. C., Srinivasa,
S. S., Pillai, P., et Campbell, J. (2008). Generalizing metamodules to simplify planning in
modular robotic systems. In Intelligent Robots and Systems, 2008. IROS 2008. IEEE/RSJ
International Conference on, pages 1338–1345, doi: 10.1109/IROS.2008.4651094.
Di Luna, G. A., Flocchini, P., Prencipe, G., Santoro, N., et Viglietta, G. (2018). Line recov-
ery by programmable particles. In Proceedings of the 19th International Conference on
Distributed Computing and Networking, pages 1–10.
Di Luna, G. A., Flocchini, P., Santoro, N., Viglietta, G., et Yamauchi, Y. (2019). Shape
formation by programmable particles. Distributed Computing, pages 1–33.
Di Luna, G. A., Flocchini, P., Santoro, N., Viglietta, G., et Yamauchi, Y. (2020). Shape
formation by programmable particles. Distributed Computing, 33(1):69–101.
Donald, B. R., Levey, C. G., McGray, C. D., Paprotny, I., et Rus, D. (2006). An untethered,
electrostatic, globally controllable mems micro-robot. Journal of microelectromechan-
ical systems, 15(1):1–15.
Dunbar, J. E., Grossman, J. W., Hattingh, J. H., Hedetniemi, S. T., et McRae, A. A. (1997).
On weakly connected domination in graphs. Discrete Mathematics, 167:261–269.
D’Angelo, G., D’Emidio, M., Das, S., Navarra, A., et Prencipe, G. (2020). Asynchronous
silent programmable matter achieves leader election and compaction. IEEE Access,
8:207619–207634.
Eiben, Á. E., Ellers, J., Meynen, G., et Nyholm, S. (2021). Robot evolution: Ethical
concerns. Frontiers in Robotics and AI, page 344.
El Baz, D., Boyer, V., Bourgeois, J., Dedu, E., et Boutoustous, K. (2012). Distributed part
differentiation in a smart surface. Mechatronics, 22(5):522–530.
El-Baz, D., Piranda, B., et Bourgeois, J. (2014). A Distributed Algorithm for a Recon-
figurable Modular Surface. In 2014 IEEE International Parallel Distributed Processing
Symposium Workshops, pages 1591–1598.
Emek, Y., Kutten, S., Lavi, R., et Moses Jr, W. K. (2019). Deterministic leader election in
programmable matter. arXiv preprint arXiv:1905.00580.
Etemad-Sajadi, R., Soussan, A., et Schöpfer, T. (2022). How ethical issues raised by
human–robot interaction can impact the intention to use the robot? International
Journal of Social Robotics, pages 1–13.
Faı́ña, A., Bellas, F., López-Peña, F., et Duro, R. J. (2013). Edhmor: Evolutionary designer
of heterogeneous modular robots. Engineering Applications of Artificial Intelligence,
26(10):2408–2423.
146 BIBLIOGRAPHY
Fitch, R., Butler, Z., et Rus, D. (2003). Reconfiguration planning for heterogeneous
self-reconfiguring robots. In Proceedings 2003 IEEE/RSJ International Conference on
Intelligent Robots and Systems (IROS 2003)(Cat. No. 03CH37453), volume 3, pages 2460–
2467. IEEE.
Fitch, R., et McAllister, R. (2013). Hierarchical planning for self-reconfiguring robots

using module kinematics. In Distributed Autonomous Robotic Systems, pages 477–490.
Springer.
Floreano, D., Husbands, P., et Nolfi, S. (2007). Evolutionary robotics. In HANDBOOK OF

ROBOTICS, CHAPTER 61:. Citeseer.
Francois-Xavier Standaert, II, E., et SYM, D. (2010). Ecrypt ii, final lightweight cryptog-
raphy status report.
Fu, G., Menciassi, A., et Dario, P. (2012). Design of a miniature switchable connection
system for stochastic modular robots. Sensors and Actuators A: Physical, 173(1):267–
276.
Fukuda, T., Buss, M., Hosokai, H., et Kawauchi, Y. (1991). Cell structured robotic system
cebot: control, planning and communication methods. Robotics and autonomous
systems, 7(2-3):239–248.
Fukuda, T., et Kawauchi, Y. (1990). Cellular robotic system (CEBOT) as one of the
realization of self-organizing intelligent universal manipulator. In Proceedings., IEEE
International Conference on Robotics and Automation, volume 1, pages 662–667. IEEE
Comput. Soc. Press, doi: 10.1109/ROBOT.1990.126059.
Gastineau, N., Abdou, W., Mbarek, N., et Togni, O. (2018). Distributed leader election and
computation of local identifiers for programmable matter. In International Symposium
on Algorithms and Experiments for Sensor Systems, Wireless Networks and Distributed
Robotics, pages 159–179. Springer.
Gilpin, K., Knaian, A., et Rus, D. (2010a). Robot pebbles: One centimeter modules for
programmable matter through self-disassembly. In 2010 IEEE International Conference
on Robotics and Automation, pages 2485–2492. IEEE, doi: 10.1109/ROBOT.2010.5509817.
Gilpin, K., Kotay, K., Rus, D., et Vasilescu, I. (2008). Miche: Modular shape formation
by self-disassembly. The International Journal of Robotics Research, 27(3-4):345–372.
Publisher: SAGE Publications.
Gilpin, K., et Rus, D. (2010b). Modular robot systems. IEEE robotics & automation
magazine, 17(3):38–55.
BIBLIOGRAPHY 147
Goldstein, S. C., Campbell, J. D., et Mowry, T. C. (2005). Programmable matter. Computer,

38(6):99–101.
Goldstein, S. C., et Mowry, T. C. (2004). Claytronics: An instance of programmable

matter. In Wild and Crazy Ideas Session of ASPLOS.
Gonzalez-Gomez, J., et Boemo, E. (2006). Motion of minimal configurations of a modular

robot: sinusoidal, lateral rolling and lateral shift. In Climbing and Walking Robots,
pages 667–674. Springer.
Guyeux, C., Makhoul, A., et Bahi, J. M. (2014). A security framework for wireless sensor
networks: Theory and practice. In Reddy, S., editor, 2014 IEEE 23rd International
WETICE Conference, WETICE 2014, Parma, Italy, 23-25 June, 2014, pages 269–274.
Hamlin, G. J., et Sanderson, A. C. (1996). Tetrobot modular robotics: Prototype and

experiments. In Proceedings of IEEE/RSJ International Conference on Intelligent Robots
and Systems. IROS’96, volume 2, pages 390–395. IEEE.
Hanley, N., et ONeill, M. (2012). Hardware comparison of the iso/iec 29192-2 block
ciphers. In 2012 IEEE Computer Society Annual Symposium on VLSI, pages 57–62. IEEE.
Hong, D., Sung, J., Hong, S., Lim, J., Lee, S., Koo, B.-S., Lee, C., Chang, D., Lee, J., Jeong,
K., et others (2006). Hight: A new block cipher suitable for low-resource device. In
International Workshop on Cryptographic Hardware and Embedded Systems, pages 46–59.
Springer.
Hong, W., Wang, S., et Shui, D. (2011). Reconfigurable robot system based on elec-
tromagnetic design. In Proceedings of 2011 International Conference on Fluid Power and
Mechatronics, pages 570–575. IEEE.
Hornby, G. S., Lipson, H., et Pollack, J. B. (2001). Evolution of generative design systems
for modular physical robots. In Proceedings 2001 ICRA. IEEE International Conference
on Robotics and Automation (Cat. No. 01CH37164), volume 4, pages 4146–4151. IEEE.
Hosokawa, K., Shimoyama, I., et Miura, H. (1994). Dynamics of self-assembling systems:

Analogy with chemical kinetics. Artificial Life, 1(4):413–427.
Ikizoglu, S., Ozer, G., et Sari, O. C. (2020). Improving the functionality and performance
of m-tran robots by constructional flexibility. International Journal of Robotics and
Automation, 2020, 35(1).
Illiano, V. P., et Lupu, E. C. (2015). Detecting malicious data injections in event detec-
tion wireless sensor networks. IEEE Transactions on Network and service management,
12(3):496–510.
148 BIBLIOGRAPHY
Inou, N., Kobayashi, H., et Koseki, M. (2002). Development of pneumatic cellular robots
forming a mechanical structure. In 7th International Conference on Control, Automation,
Robotics and Vision, 2002. ICARCV 2002., volume 1, pages 63–68. IEEE.
Jensen, I., et Guttmann, A. J. (2000). Statistics of lattice animals (polyominoes)

and polygons. Journal of Physics A: Mathematical and General, 33(29):L257–L263,
doi: 10.1088/0305-4470/33/29/102.
Jiang, F., Cheng, Y., Dong, C., et Yu, E. (2020). A novel weight-based leader election
approach for split brain in distributed system. In IOP Conference Series: Materials
Science and Engineering, page 012005. IOP Publishing.
Jones, C., et Mataric, M. J. (2003). From local to global behavior in intelligent self-
assembly. In 2003 IEEE International Conference on Robotics and Automation (Cat. No.
03CH37422), volume 1, pages 721–726. IEEE.
Jorgensen, M. W., Ostergaard, E. H., et Lund, H. H. (2004). Modular ATRON: mod-

ules for a self-reconfigurable robot. In 2004 IEEE/RSJ International Conference on
Intelligent Robots and Systems (IROS), volume 2, pages 2068–2073, Sendai, Japan,
doi: 10.1109/IROS.2004.1389702. ISSN: null.
Kamimura, A., Yoshida, E., Murata, S., Tomita, K., et Kokaji, S. (2002). A Self-
Reconfigurable Modular Robot (MTRAN) – Hardware and Motion Generation Soft-
ware –. In 5th International Symposium on Distributed Autonomous Robotic Systems,
page 10.
Karagozler, M. E. (2012). Design, fabrication and characterization of an autonomous,

sub-millimeter scale modular robot. PhD thesis, Carnegie Mellon University.
Karagozler, M. E., Campbell, J. D., Fedder, G. K., Goldstein, S. C., Weller, M. P., et Yoon,
B. W. (2007). Electrostatic latching for inter-module adhesion, power transfer, and
communication in modular robots. In 2007 IEEE/RSJ International Conference on Intel-
ligent Robots and Systems, pages 2779–2786. IEEE.
Karagozler, M. E., Goldstein, S. C., et Reid, J. R. (2009). Stress-driven mems assembly +

electrostatic forces = 1mm diameter robot. In Proceedings of the IEEE International
Conference on Intelligent Robots and Systems (IROS ’09).
Katagi, M., Moriai, S., et others (2008). Lightweight cryptography for the internet of
things. Sony Corporation, pages 7–10.
Kernbach, S., Girault, B., et Kernbach, O. (2011). On self-optimized self-assembling of

heterogeneous multi-robot organisms. In Bio-inspired self-organizing robotic systems,
pages 123–141. Springer.
BIBLIOGRAPHY 149
Kirby, B., Campbell, J., Aksak, B., Pillai, P., Hoburg, J., Mowry, T. C., et Goldstein, S. C.
(2005). Catoms: Moving robots without moving parts. In Proceedings of the national
conference on artificial intelligence, volume 20, page 1730. Menlo Park, CA; Cambridge,
MA; London; AAAI Press; MIT Press; 1999.
Kirby, B. T., Ashley-Rollman, M., et Goldstein, S. C. (2011). Blinky blocks: a physical

ensemble programming platform. In CHI ’11 Extended Abstracts on Human Factors in
Computing Systems, CHI EA ’11, pages 1111–1116, New York, NY, USA. ACM.
Klidbary, S. H., Shouraki, S. B., et Faraji, S. (2013). Finding proper configurations for
modular robots by using genetic algorithm on different terrains. Int J Mater Mech
Manuf, 1(4):360–365.
Ko, D., et Cheng, H. (2010). Reconfigurable software for reconfigurable modular robots.
In Proceedings of ICRA 2010 Workshop Modular Robots: State of the Art, page 100.
Kuhn, H. W. (1955). Kuhn hw. the hungarian method for the assignment problem. naval
research logistic quaterly 1955; 2: 83-97. Naval Research Logistic Quaterly, 2:83–97.
Kumar, V., Jha, R. K., et Jain, S. (2020). Nb-iot security: A survey. Wireless Personal
Communications, 113(4):2661–2708, doi: 10.1007/s11277-020-07346-7.
Kurokawa, H., Kamimura, A., Yoshida, E., Tomita, K., Kokaji, S., et Murata, S. (2003). M-
tran ii: metamorphosis from a four-legged walker to a caterpillar. In Proceedings 2003
IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS 2003)(Cat.
No. 03CH37453), volume 3, pages 2454–2459. IEEE.
Kurokawa, H., Kamimura, A., Yoshida, E., Tomita, K., Murata, S., et Kokaji, S. (2002). Self-
reconfigurable modular robot (m-tran) and its motion design. In 7th International
Conference on Control, Automation, Robotics and Vision, 2002. ICARCV 2002., volume 1,
pages 51–56. IEEE.
Kurokawa, H., Tomita, K., Kamimura, A., Kokaji, S., Hasuo, T., et Murata, S. (2008).
Distributed self-reconfiguration of m-tran iii modular robotic system. The International
Journal of Robotics Research, 27(3-4):373–386.
Kurokawa, H., Tomita, K., Yoshida, E., Murata, S., et Kokaji, S. (2000). Motion simulation
of a modular robotic system. In 2000 26th Annual Conference of the IEEE Industrial Elec-
tronics Society. IECON 2000. 2000 IEEE International Conference on Industrial Electronics,
Control and Instrumentation. 21st Century Technologies, volume 4, pages 2473–2478. IEEE.
Lee, E., Yang, J., Jolda, M., et Wood, R. (2010). Cellular slime mold robot. In the
International Conference on Robotics and Automation Workshop, Modular Robots: State
of the Art, pages 30–35.
150 BIBLIOGRAPHY
Lipson, H., et Pollack, J. B. (2000). Automatic design and manufacture of robotic life-
forms. Nature, 406(6799):974–978.
Lu, Y., Chen, J., Comsa, I., Kuonen, P., et Hirsbrunner, B. (2014). Construction of data ag-
gregation tree for multi-objectives in wireless sensor networks through jump particle
swarm optimization. Procedia Computer Science, 35:73–82.
Luna, G. A. D., Flocchini, P., Santoro, N., Viglietta, G., et Yamauchi, Y. (2017). Brief An-
nouncement: Shape Formation by Programmable Particles. In Richa, A. W., editor,
31st International Symposium on Distributed Computing (DISC 2017), volume 91 of Leib-
niz International Proceedings in Informatics (LIPIcs), pages 48:1–48:3, Dagstuhl, Germany.
Schloss Dagstuhl–Leibniz-Zentrum fuer Informatik, doi: 10.4230/LIPIcs.DISC.2017.48.
Luna, G. A. D., Flocchini, P., Santoro, N., Viglietta, G., et Yamauchi, Y. (2020). Mobile ram
and shape formation by programmable particles. In European Conference on Parallel
Processing, pages 343–358. Springer.
Lyder, A., Garcia, R. F. M., et Stoy, K. (2008). Mechanical design of odin, an extendable
heterogeneous deformable modular robot. In 2008 IEEE/RSJ International Conference
on Intelligent Robots and Systems, pages 883–888. Ieee.
McCorkle, M. L. (2018 (accessed November 3, 2020)). ORNL Launches Summit Super-

computer. https://www.ornl.gov/news/ornl-launches-summit-supercomputer.
Miyashita, S., Kessler, M., et Lungarella, M. (2008). How morphology affects self-assembly
in a stochastic modular robot. In 2008 IEEE International Conference on Robotics and
Automation, pages 3533–3538. IEEE.
Moeckel, R., Jaquier, C., Drapel, K., Dittrich, E., Upegui, A., et Ijspeert, A. (2006). YaMoR
and Bluemove — An Autonomous Modular Robot with Bluetooth Interface for Ex-
ploring Adaptive Locomotion. In Tokhi, M. O., Virk, G. S., et Hossain, M. A., editors,
Climbing and Walking Robots, pages 685–692. Springer Berlin Heidelberg, Berlin, Heidel-
berg, doi: 10.1007/3-540-26415-9̇82.
Moussa, M., Piranda, B., Makhoul, A., et Bourgeois, J. (2021). Cluster-based distributed
self-reconfiguration algorithm for modular robots. In Barolli, L., Woungang, I., et
Enokido, T., editors, Advanced Information Networking and Applications - Proceedings of
the 35th International Conference on Advanced Information Networking and Applications
(AINA-2021), Toronto, ON, Canada, 12-14 May, 2021, Volume 1, volume 225 of Lecture
Notes in Networks and Systems, pages 332–344. Springer.
Murata, S., et Kurokawa, H. (2007). Self-reconfigurable robots. IEEE Robotics & Automa-
tion Magazine, 14(1):71–78.
BIBLIOGRAPHY 151
Murata, S., et Kurokawa, H. (2012a). The future of self-organizing robots. In Self-

Organizing Robots, pages 235–246. Springer.
Murata, S., et Kurokawa, H. (2012b). Prototypes of self-organizing robots. In Self-

Organizing Robots, pages 105–130. Springer.
Murata, S., Yoshida, E., Kamimura, A., Kurokawa, H., Tomita, K., et Kokaji, S. (2002).
M-tran: Self-reconfigurable modular robotic system. IEEE/ASME transactions on
mechatronics, 7(4):431–441.
Nagy, Z., Oung, R., Abbott, J. J., et Nelson, B. J. (2008). Experimental inves-
tigation of magnetic self-assembly for swallowable modular robots. In 2008
IEEE/RSJ International Conference on Intelligent Robots and Systems, pages 1915–1920,
doi: 10.1109/IROS.2008.4650662.
Napp, N., Burden, S., et Klavins, E. (2006). The statistical dynamics of programmed self-
assembly. In Proceedings 2006 IEEE International Conference on Robotics and Automation,
2006. ICRA 2006., pages 1469–1476. IEEE.
Naz, A., Piranda, B., Bourgeois, J., et Goldstein, S. C. (2016a). A distributed self-
reconfiguration algorithm for cylindrical lattice-based modular robots. In 2016 IEEE
15th International Symposium on Network Computing and Applications (NCA), pages 254–
263. IEEE.
Naz, A., Piranda, B., Bourgeois, J., et Goldstein, S. C. (2018a). Electing an approximate
center in a huge modular robot with the k-bfs sumsweep algorithm. In 2018 IEEE/RSJ
International Conference on Intelligent Robots and Systems (IROS), pages 4825–4832.
Naz, A., Piranda, B., Bourgeois, J., et Goldstein, S. C. (2018b). A time synchronization
protocol for large-scale distributed embedded systems with low-precision clocks and
neighbor-to-neighbor communications. Journal of Network and Computer Applications,
105:123 – 142.
Naz, A., Piranda, B., Goldstein, S. C., et Bourgeois, J. (2015). ABC-Center: Approximate-
center election in modular robots. In 2015 IEEE/RSJ International Conference on
Intelligent Robots and Systems (IROS), pages 2951–2957, Hamburg, Germany. IEEE,
doi: 10.1109/IROS.2015.7353784.
Naz, A., Piranda, B., Goldstein, S. C., et Bourgeois, J. (2016b). A time synchronization
protocol for modular robots. In 2016 24th Euromicro International Conference on Parallel,
Distributed, and Network-Based Processing (PDP), pages 109–118. IEEE.
Naz, A., Piranda, B., Tucci, T., Copen Goldstein, S., et Bourgeois, J. (2018c). Network Char-
acterization of Lattice-Based Modular Robots with Neighbor-to-Neighbor Commu-
152 BIBLIOGRAPHY
nications. In Distributed Autonomous Robotic Systems, volume 6, pages 415–429, Cham.

Springer International Publishing.
Nolfi, S., et Floreano, D. (2000). Evolutionary robotics: The biology, intelligence, and
technology of self-organizing machines. MIT press.
Ogundoyin, S. O. (2020). An autonomous lightweight conditional privacy-preserving

authentication scheme with provable security for vehicular ad-hoc networks. Inter-
national Journal of Computers and Applications, 42(2):196–211.
Østergaard, E. H., Kassow, K., Beck, R., et Lund, H. H. (2006). Design of the atron
lattice-based self-reconfigurable robot. Autonomous Robots, 21(2):165–183.
Ostergaard, E. H., et Lund, H. H. (2003). Evolving control for modular robotic units. In
Proceedings 2003 IEEE International Symposium on Computational Intelligence in Robotics
and Automation. Computational Intelligence in Robotics and Automation for the New Mil-
lennium (Cat. No. 03EX694), volume 2, pages 886–892. IEEE.
Park, M., Chitta, S., Teichman, A., et Yim, M. (2008). Automatic configuration recogni-
tion methods in modular robots. The Int. Jour. of Robotics Research, 27(3-4):403–421,
doi: 10.1177/0278364907089350.
Patitz, M. J. (2012). An introduction to tile-based self-assembly. In Durand-Lose, J., et

Jonoska, N., editors, Unconventional Computation and Natural Computation, pages 34–62,
Berlin, Heidelberg. Springer Berlin Heidelberg.
Paul, C., et Bongard, J. C. (2001). The road less travelled: Morphology in the optimiza-
tion of biped robot locomotion. In Proceedings 2001 IEEE/RSJ International Conference
on Intelligent Robots and Systems. Expanding the Societal Role of Robotics in the the Next
Millennium (Cat. No. 01CH37180), volume 1, pages 226–232. IEEE.
Pavliuk, N., Saveliev, A., Cherskikh, E., et Pykhov, D. (2020). Formation of modular
structures with mobile autonomous reconfigurable system. In Proceedings of 14th
International Conference on Electromechanics and Robotics “Zavalishin’s Readings”, pages
383–395. Springer.
Perrin, D. (2008). La suite logistique et le chaos. Rapport technique, Dép. Math. d’Orsay.,
Univ. de Paris-Sud, France, 22.
Pierre, T. (2019). Distributed Algorithms and Advanced Modeling Approaches for Fast
and Efficient Object Construction Using a Modular Self-reconfigurable Robotic Sys-
tem. PhD thesis.
Piranda, B., et Bourgeois, J. (2018). Designing a quasi-spherical module for a huge

modular robot to create programmable matter. Autonomous Robots, 42(8):1619–1633,
doi: 10.1007/s10514-018-9710-0.
BIBLIOGRAPHY 153
Piranda, B., Chodkiewicz, P., Hołobut, P., Bordas, S. P., Bourgeois, J., et Lengiewicz, J.
(2021). Distributed prediction of unsafe reconfiguration scenarios of modular robotic
programmable matter. IEEE Transactions on Robotics, 37(6):2226–2233.
Piranda, B., Fekete, S., Richa, A., Römer, K., et Scheideler, C. (2016). Visiblesim: Your
simulator for programmable matter. In Algorithmic Foundations of Programmable Matter
(Dagstuhl Seminar 16271). https://projects.femto-st.fr/projet-visiblesim/en.
Piranda, B., Laurent, G. J., Bourgeois, J., Clévy, C., Möbes, S., et Fort-Piat, N. L. (2013). A
new concept of planar self-reconfigurable modular robot for conveying microparts.
Mechatronics, 23(7):906–915, doi: 10.1016/j.mechatronics.2013.08.009.
Preneel, B., Govaerts, R., et Vandewalle, J. (1993). Hash functions based on block ciphers:
A synthetic approach. In Annual International Cryptology Conference, pages 368–378.
Springer.
Regin, R., Rajest, S. S., et Singh, B. (2021). Fault detection in wireless sensor network
based on deep learning algorithms. EAI Endorsed Transactions on Scalable Information
Systems.
Requicha, A. A., et Voelcker, H. B. (1977). Constructive solid geometry.
Rogaway, P., et Steinberger, J. (2008). Constructing cryptographic hash functions from

fixed-key blockciphers. In Annual International Cryptology Conference, pages 433–450.
Springer.
Romanishin, J. W., Gilpin, K., et Rus, D. (2013). M-blocks: Momentum-driven, magnetic

modular robots. In 2013 IEEE/RSJ International Conference on Intelligent Robots and
Systems, pages 4288–4295, Tokyo. IEEE, doi: 10.1109/IROS.2013.6696971.
Rothemund, P. W. (2006). Folding dna to create nanoscale shapes and patterns. Nature,
440(7082):297–302.
Rothemund, P. W., et Winfree, E. (2000). The program-size complexity of self-assembled

squares. In Proceedings of the thirty-second annual ACM symposium on Theory of com-
puting, pages 459–468.
Rus, D., et Vona, M. (2000). A physical implementation of the self-reconfiguring crys-

talline robot. In Proceedings 2000 ICRA. Millennium Conference. IEEE International Confer-
ence on Robotics and Automation. Symposia Proceedings (Cat. No.00CH37065), volume 2,
pages 1726–1733, San Francisco, CA, USA. IEEE, doi: 10.1109/ROBOT.2000.844845.
Rus, D., et Vona, M. (2001). Crystalline robots: Self-reconfiguration with compressible

unit modules. Autonomous Robots, 10(1):107–124.
154 BIBLIOGRAPHY
Ryland, G. G., et Cheng, H. H. (2010). Design of imobot, an intelligent reconfigurable

mobile robot with novel locomotion. In 2010 IEEE International Conference on Robotics
and Automation, pages 60–65. IEEE.
Salemi, B., Moll, M., et Shen, W.-m. (2006). SUPERBOT: A Deployable, Multi-
Functional, and Modular Self-Reconfigurable Robotic System. In 2006 IEEE/RSJ In-
ternational Conference on Intelligent Robots and Systems, pages 3636–3641, Beijing, China.
IEEE, doi: 10.1109/IROS.2006.281719.
Santos-González, I., Rivero-Garcı́a, A., Burmester, M., Munilla, J., et Caballero-Gil, P. (2020).
Secure lightweight password authenticated key exchange for heterogeneous wireless
sensor networks. Information Systems, 88:101423.
Sarker, V. K., Gia, T. N., Tenhunen, H., et Westerlund, T. (2020). Lightweight security
algorithms for resource-constrained iot-based sensor nodes. In ICC 2020-2020 IEEE
International Conference on Communications (ICC), pages 1–7. IEEE.
Schneider, J., et Wattenhofer, R. (2011). Trading bit, message, and time complexity of
distributed algorithms. In Peleg, D., editor, Distributed Computing, pages 51–65, Berlin,
Heidelberg. Springer Berlin Heidelberg.
Seo, J., Yim, M., et Kumar, V. (2013). Assembly planning for planar structures of a brick
wall pattern with rectangular modular robots. In 2013 IEEE International Conference
on Automation Science and Engineering (CASE), pages 1016–1021. IEEE.
Shih, W. M., Quispe, J. D., et Joyce, G. F. (2004). A 1.7-kilobase single-stranded dna

that folds into a nanoscale octahedron. Nature, 427(6975):618–621.
Shimizu, M., Ishiguro, A., et Kawakatsu, T. (2005). A modular robot that exploits a spon-
taneous connectivity control mechanism. In 2005 IEEE/RSJ International Conference
on Intelligent Robots and Systems, pages 1899–1904. IEEE.
Shimizu, M., et Suzuki, K. (2009). A self-repairing structure for modules and its control
by vibrating actuation mechanisms. In 2009 IEEE International Conference on Robotics
and Automation, pages 4281–4286. IEEE.
Shirai, T., Shibutani, K., Akishita, T., Moriai, S., et Iwata, T. (2007). The 128-bit blockci-
pher clefia. In International workshop on fast software encryption, pages 181–195. Springer.
Sproewitz, A., Billard, A., Dillenbourg, P., et Ijspeert, A. J. (2009). Roombots-mechanical

design of self-reconfiguring modular robots for adaptive furniture. In 2009 IEEE
international conference on robotics and automation, pages 4259–4264. IEEE.
Spröwitz, A., Moeckel, R., Vespignani, M., Bonardi, S., et Ijspeert, A. J. (2014). Roombots: A
hardware perspective on 3d self-reconfiguration and locomotion with a homogeneous
modular robot. Robotics and Autonomous Systems, 62(7):1016–1033.
BIBLIOGRAPHY 155
Stoller, S. D. (2000). Leader election in asynchronous distributed systems. IEEE trans-

actions on computers, 49(3):283–284.
Stoy, K. (2006). Using cellular automata and gradients to control self-reconfiguration.

Robotics and Autonomous Systems, 54(2):135–141.
Stoy, K., et Nagpal, R. (2004). Self-reconfiguration using directed growth. In In Proc. 7th
Int. Symp. on Distributed Autonomous Robotic Systems, pages 1–10.
Suh, J. W., Homans, S. B., et Yim, M. (2002). Telecubes: Mechanical design of a module
for self-reconfigurable robotics. In Proceedings 2002 IEEE International Conference on
Robotics and Automation (Cat. No. 02CH37292), volume 4, pages 4095–4101. IEEE.
Thalamy, P. (2020). Distributed algorithms and advanced modeling approaches for fast
and efficient object construction using a modular self-reconfigurable robotic system.
PhD thesis. Thèse de doctorat dirigée par Bourgeois, Julien et Piranda, Benoı̂t Informatique
Bourgogne Franche-Comté 2020.
Thalamy, P., Piranda, B., et Bourgeois, J. (2019a). Distributed Self-reconfiguration using

a Deterministic Autonomous Scaffolding Structure. Research Report 2843, UBFC.
Thalamy, P., Piranda, B., et Bourgeois, J. (2019b). A survey of autonomous self-

reconfiguration methods for robot-based programmable matter. Robotics and Au-
tonomous Systems, 120:103242.
Thalamy, P., Piranda, B., et Bourgeois, J. (2020a). 3d coating self-assembly for modular
robotic scaffolds. In 2020 IEEE/RSJ International Conference on Intelligent Robots and
Systems (IROS), pages 11688–11695. IEEE.
Thalamy, P., Piranda, B., Lassabe, F., et Bourgeois, J. (2020b). Deterministic scaffold
assembly by self-reconfiguring micro-robotic swarms. Swarm and Evolutionary Compu-
tation, 58:100722, doi: https://doi.org/10.1016/j.swevo.2020.100722.
Thalamy, P., Piranda, B., Naz, A., et Bourgeois, J. (2021). Behavioral simulations of
lattice modular robots with visiblesim. In 15th International Symposium on Distributed
Autonomous Robotic Systems (DARS 2021), Kyoto, Japan.
Toffoli, T., et Margolus, N. (1991). Programmable matter: Concepts and realiza-

tion. Physica D: Nonlinear Phenomena, 47(1):263–272, doi: https://doi.org/10.1016/0167-
2789(91)90296-L.
Tolley, M. T., Hiller, J. D., et Lipson, H. (2011a). Evolutionary design and assembly
planning for stochastic modular robots. In Doncieux, S., Bredèche, N., et Mouret, J.-B.,
editors, New Horizons in Evolutionary Robotics, pages 211–225, Berlin, Heidelberg. Springer
Berlin Heidelberg.
156 BIBLIOGRAPHY
Tolley, M. T., Krishnan, M., Erickson, D., et Lipson, H. (2008). Dynamically programmable
fluidic assembly. Applied Physics Letters, 93(25):254105, doi: 10.1063/1.3048562.
Tolley, M. T., et Lipson, H. (2010). Fluidic manipulation for scalable stochastic 3d assem-
bly of modular robots. In 2010 IEEE International Conference on Robotics and Automation,
pages 2473–2478, doi: 10.1109/ROBOT.2010.5509664.
Tolley, M. T., et Lipson, H. (2011b). On-line assembly planning for stochastically re-
configurable systems. The International Journal of Robotics Research, 30(13):1566–1584,
doi: 10.1177/0278364911398160.
Tosun, T., Jing, G., Kress-Gazit, H., et Yim, M. (2018). Computer-aided compositional de-
sign and verification for modular robots. In Robotics Research, pages 237–252. Springer.
Tucci, T., Piranda, B., et Bourgeois, J. (2017). Efficient scene encoding for programmable
matter self-reconfiguration algorithms. In Proceedings of the Symposium on Applied
Computing, pages 256–261.
Tucci, T. K., Piranda, B., et Bourgeois, J. (2018). A distributed self-assembly planning

algorithm for modular robots. In International Conference on Autonomous Agents and
Multiagent Systems.
Tummala, R. L., Mukherjee, R., Aslam, D., Xi, N., Mahadevan, S., et Weng, J. (1999).
Reconfigurable adaptable micro-robot. In IEEE SMC’99 Conference Proceedings. 1999
IEEE International Conference on Systems, Man, and Cybernetics (Cat. No. 99CH37028),
volume 6, pages 687–691. IEEE.
Ünsal, C., Kiliççöte, H., et Khosla, P. K. (2001). A modular self-reconfigurable bipartite

robotic system: Implementation and motion planning. Autonomous Robots, 10(1):23–
40.
Wazid, M., Das, A. K., Bhat, V., et Vasilakos, A. V. (2020). Lam-ciot: Lightweight authen-
tication mechanism in cloud-based iot environment. Journal of Network and Computer
Applications, 150:102496.
Wei, H., Cai, Y., Li, H., Li, D., et Wang, T. (2010). Sambot: A self-assembly modular
robot for swarm robot. In Proceedings - IEEE International Conference on Robotics and
Automation, pages 66–71.
Werfel, J. (2006). Anthills built to order: Automating construction with artificial swarms.
White, P., Kopanski, K., et Lipson, H. (2004). Stochastic self-reconfigurable cellular

robotics. In IEEE International Conference on Robotics and Automation, 2004. Proceedings.
ICRA’04. 2004, volume 3, pages 2888–2893. IEEE.
BIBLIOGRAPHY 157
White, P., Zykov, V., Bongard, J. C., Lipson, H., et others (2005). Three dimensional
stochastic reconfiguration of modular robots. In Robotics: Science and Systems, pages
161–168. Citeseer.
White, P. J., et Yim, M. (2007). Scalable modular self-reconfigurable robots using ex-
ternal actuation. In 2007 IEEE/RSJ International Conference on Intelligent Robots and
Systems, pages 2773–2778, doi: 10.1109/IROS.2007.4399606.
Will, P. M., Castaño, A., et Shen, W.-M. (1999). Robot modularity for self-reconfiguration.
In Sensor Fusion and Decentralized Control in Robotic Systems II, volume 3839, pages 236–
245. SPIE.
Wolfe, K. C., Moses, M. S., Kutzer, M. D., et Chirikjian, G. S. (2012). M 3 express: a low-
cost independently-mobile reconfigurable modular robot. In 2012 IEEE International
Conference on Robotics and Automation, pages 2704–2710. IEEE.
Woods, D., Chen, H.-L., Goodfriend, S., Dabby, N., Winfree, E., et Yin, P. (2013). Active self-
assembly of algorithmic shapes and patterns in polylogarithmic time. In Proceedings of
the 4th conference on Innovations in Theoretical Computer Science, pages 353–354. ACM.
YIM, M. (1993). A reconfigurable modular robot with multiple modes of locomotion.

Proc. of the 1993 JSME Conference on Advanced Mechatronics, Tokyo, Japan.
Yim, M. (1994). Locomotion with a Unit Modular Recon-figurable Robot. PhD thesis,
PhD Thesis, Dept. of Mech. Eng. Stanford Univ.
Yim, M., Duff, D. G., et Roufas, K. D. (2000). Polybot: a modular reconfigurable robot. In
Proceedings 2000 ICRA. Millennium Conference. IEEE International Conference on Robotics
and Automation. Symposia Proceedings (Cat. No. 00CH37065), volume 1, pages 514–520.
IEEE.
Yim, M., Eldershaw, C., Zhang, Y., et Duff, D. (2003a). Self-reconfigurable robot systems:
Polybot. Journal of the Robotics Society of Japan, 21(8):851–854.
Yim, M., Lamping, J., Mao, E., et Chase, J. G. (1997). Rhombic dodecahedron shape for
self-assembling robots. In Xerox PARC SPL, Tech. Rep. P9710777. Citeseer.
Yim, M., Roufas, K., Duff, D., Zhang, Y., Eldershaw, C., et Homans, S. (2003b). Modular
reconfigurable robots in space applications. Autonomous Robots, 14(2):225–237.
Yim, M., Shen, W.-M., Salemi, B., Rus, D., Moll, M., Lipson, H., Klavins, E., et Chirikjian,
G. S. (2007). Modular self-reconfigurable robot systems [grand challenges of
robotics]. IEEE Robotics & Automation Magazine, 14(1):43–52.
Yim, M., Zhang, Y., et Duff, D. (2002a). Modular robots. IEEE Spectrum, 39(2):30–34,
doi: 10.1109/6.981854.
158 BIBLIOGRAPHY
Yim, M., Zhang, Y., Lamping, J., et Mao, E. (2001). Distributed Control for 3D Meta-
morphosis. Autonomous Robots, 10(1):41–56, doi: 10.1023/A:1026544419097.
Yim, M., Zhang, Y., Roufas, K., Duff, D., et Eldershaw, C. (2002b). Connecting and
disconnecting for chain self-reconfiguration with polybot. IEEE/ASME Transactions
on Mechatronics, 7(4):442–451, doi: 10.1109/TMECH.2002.806221.
Yoshida, E., Kokaji, S., Murata, S., Kurokawa, H., et Tomita, K. (1999). Miniaturized self-
reconfigurable system using shape memory alloy. In Proceedings 1999 IEEE/RSJ Inter-
national Conference on Intelligent Robots and Systems. Human and Environment Friendly
Robots with High Intelligence and Emotional Quotients (Cat. No.99CH36289), volume 3,
pages 1579–1585 vol.3, doi: 10.1109/IROS.1999.811704.
Youssef, Y. M. (2021). Inducing rules about distributed robotic systems for fault de-
tection & diagnosis. In Proceedings of the 20th International Conference on Autonomous
Agents and MultiAgent Systems, pages 1845–1847.
Yu, C.-H., Werfel, J. K., et Nagpal, R. (2010). Collective decision-making in multi-agent

systems by implicit leadership. Association for Computing Machinery Press, 2010.
Yurke, B., Turberfield, A. J., Mills, A. P., Simmel, F. C., et Neumann, J. L. (2000). A
dna-fuelled molecular machine made of dna. Nature, 406(6796):605–608.
ZHANG, X., et FEI, Y.-q. (2008). A self-repair algorithm for self-reconfigurable modular
robots based on geometrical characteristics. Journal of Shanghai Jiaotong University,
2008, 7.
Zhao, J., Cui, X., Zhu, Y., et Tang, S. (2011). A new self-reconfigurable modular robotic
system ubot: Multi-mode locomotion and self-reconfiguration. In 2011 IEEE Interna-
tional Conference on Robotics and Automation, pages 1020–1025. IEEE.
Zhao, J., Cui, X., Zhu, Y., et Tang, S. (2012). Ubot: a new reconfigurable modular robotic
system with multimode locomotion ability. Industrial Robot: An International Journal.
Zhong, H., Li, Z., Zhang, H., Yu, C., et Li, N. (2010). Modular robot path planning
using genetic algorithm based on gene pool. In International Symposium on Intelligence
Computation and Applications, pages 380–389. Springer.
Zhu, L., et El Baz, D. (2019). A programmable actuator for combined motion

and connection and its application to modular robot. Mechatronics, 58:9–19,
doi: 10.1016/j.mechatronics.2019.01.002.
Zhu, W.-H., et Lamarche, T. (2007). Modular robot manipulators based on virtual de-
composition control. In Proceedings 2007 IEEE International Conference on Robotics and
Automation, pages 2235–2240. IEEE.
BIBLIOGRAPHY 159
Zhu, Y., Zhao, J., Cui, X., Wang, X., Tang, S., Zhang, X., et Yin, J. (2013). De-
sign and implementation of ubot: A modular self-reconfigurable robot. In
2013 IEEE International Conference on Mechatronics and Automation, pages 1217–1222,
doi: 10.1109/ICMA.2013.6618087.
Zou, Y., et Krishnendu Chakrabarty (2003). Sensor deployment and target localization
based on virtual forces. In IEEE INFOCOM 2003. Twenty-second Annual Joint Conference
of the IEEE Computer and Communications Societies (IEEE Cat. No.03CH37428), volume 2,
pages 1293–1303 vol.2.
Zykov, V., Chan, A., et Lipson, H. (2007a). Molecubes: An open-source modular robotics
kit. In IROS-2007 Self-Reconfigurable Robotics Workshop, pages 3–6. Citeseer.
Zykov, V., Lipson, H., et others (2007b). Experiment design for stochastic three-
dimensional reconfiguration of modular robots. In IEEE Int. Conf. Intell. Robots Syst.,
Self-Reconfigurable Robot. Workshop, San Diego, CA. Citeseer.
Zykov, V., Phelps, W., Lassabe, N., Lipson, H., et others (2008). Molecubes ex-
tended: Diversifying capabilities of open-source modular robotics. In IROS-2008
Self-Reconfigurable Robotics Workshop, pages 22–26. Citeseer.
List of Figures
2.1 The MITE framework for characterizing Modular Robotic Systems Ahmadzadeh
et al. (2016) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.2 A real image of Catom2D, Karagozler et al. (2009) . . . . . . . . . . . . . . . 26
2.3 Catom3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.4 Examples of modular robots: Figure 2.4a represents a polybot introduced in Yim
et al. (2000); Figure 2.4b is a Tripod configuration of CONRO Castano et al.
(2000); Figure 2.4c is a Five YaMoR modules Moeckel et al. (2006); Figure 2.4d
is a lattice modular robot called ATRON Jorgensen et al. (2004); Figure 2.4e
is a Rotating M-Block Romanishin et al. (2013); Figure 2.4f is a 2D Crystalline
Rus et al. (2000) modular robots with extensible arms; Figure 2.4g is a Superbot
Salemi et al. (2006) modular robot in a humanoid configuration. Figure 2.4h
M-TRAN Kamimura et al. (2002) modular robot in 4-legged configuration;
Figure 2.4i is a SMORES Davey et al. (2012) modular robot. . . . . . . . . . 29
3.1 Examples of weight generation based on the interfaces connections for two
different 2D lattices (cubic on the left similar to Blinky blocks that are the
modules used in this thesis, and hexagonal on the right as another example on
how to generate weight based on interface connection, however this model was
not used in this thesis). Grey triangles mark #0 connectors, others are placed
clockwise. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.2 5 steps of the recruitment process: Roots start recruiting modules until no more
modules are available. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.3 Group value computation: Starting from the leaf of each group, each leaf sends
its weight to its parent. The parent adds the received value with its weight and
then send the result backward until it reaches the root of the tree. Once the
sum reaches the root, it will be added to the root’s weight to define the group
value. This group value is then broadcast to all the modules of the tree. . . . . 52
3.4 Activity Diagram when receiving win/lost messages . . . . . . . . . . . . . . . 54
161
162 LIST OF FIGURES
3.5 4 steps of the dismantling recruitment: First step presents the initial state, step
2 shows the competition between the two groups, the blue group win on the
green group, then each leaf of the two groups produces reset and dismantle
messages. Step 3 shows the broadcasting of reset and dismantle messages. At
the end, step 4, their is only one group and nodes are reset. . . . . . . . . . . 56
3.6 Leader election: 1) Once a module can not recruit or compete further, it sends
a Potential Leader message (PL) to its parent. 2)& 3) Each parent that receives
PL message waits for all its children PL message and then sends it backward
to its parent. 4) So far until the message reaches the root, which becomes the
leader and broadcast (5) to all modules in the system that the leader is elected. 58
3.7 Comparison of two cases, a) and b) has the same blue and green trees but b)
has yellow modules in addition. In the case b), yellow tree will dramatically
change the results. The yellow tree will be loosing against the blue tree, and it
will be then merged into one tree. So in this case having two identical trees is
not considered as a conflict. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
3.8 Example of initial configuration with m = 4. . . . . . . . . . . . . . . . . . . . 62
3.9 The 3 configurations of Blinky Blocks used in the simulation . . . . . . . . . . 63
3.10 Execution time Vs. number of modules . . . . . . . . . . . . . . . . . . . . . . 64
3.11 Time complexity comparison between the proposed algorithm and ? . . . . . . 65
3.12 Number of messages exchanged Vs. the number of modules . . . . . . . . . . 65
3.13 Message complexity comparison between the proposed algorithm and ? . . . . 66
3.14 Detailed diagram of the leader election process . . . . . . . . . . . . . . . . . 67
4.1 Invalid Node Motion according to Condition 1. The red module (#3) is a
module with 2 connections. Thus a pivot for rotation is not possible. . . . . . . 74
4.3 Repulsive and attractive VF . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
4.4 Different goal shapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
4.5 Simulation Results of the ”UFC”-like shape. . . . . . . . . . . . . . . . . . . . 84
4.6 Simulation Results of the humanoid shape. . . . . . . . . . . . . . . . . . . . . 84
5.1 Potential Neighbors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91

LIST OF FIGURES 163
5.2 Different examples of Partial and complete disconnections: Figures 5.2a and
5.2b Represents a partial disconnection. In Figure 5.2a. modules A and B are
disconnected, but they still are part of the whole system since they can maintain
their connection to the system through their neighbors C and D. Figures 5.2c
and 5.2d are in a state of complete disconnection. In Figure 5.2c, module A
is disconnected from module B and module A is not connected to any other
module. Therefore, module A is considered to be in complete disconnection
from the system since there is no other way for the system to acknowledge its
presence. Same case for Figure 5.2d. . . . . . . . . . . . . . . . . . . . . . . 92
5.3 The recruitment process diagram. . . . . . . . . . . . . . . . . . . . . . . . . 94
5.4 Data collection in a dense system: Module 6 will add to the potentialNeigh-
borsVector the following coordinates: (2, 2) and (3, 1), Module 8 will add (3, 0)
and Module 9 will add (3, −1) and (2, −2). They will then send this vector
to their respective parents 5, 4, and 7. Module 5 will add (1, 2), Module 7
will add (1, −2), and Module 4 will not add anything since all its interfaces are
connected. So on until this vector reaches the leader. . . . . . . . . . . . . . . 96
5.5 This figure shows, on a logarithmic scale, how the number of messages sent
in a 1,000 3D system is changing with the density of the system. Each color
represents the percentage of errors that existed in the system during the sim-
ulations. It is noticeable that the number of messages is increasing with the
density. Furthermore, the number of messages decreases when the percentage
of errors is increasing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
5.6 This figure shows, on a logarithmic scale (Natural log on the X axis), the
number of messages sent in the system according to the number of modules
in a logarithmic scale. The shape used in those simulation was a cube. The
colors represent the percentage of errors in the system during the simulations.
The results shows that the number of messages sent is linear when compared
to the number of modules in the system. . . . . . . . . . . . . . . . . . . . . . 98
5.7 Percentage of errors detected. This figures shows the percentage of error de-
tected . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
6.1 Results of ECRYPT II ordered by code size and RAM use . . . . . . . . . . . . 104
6.2 EBIOS Process . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
6.3 Connection between two different structures . . . . . . . . . . . . . . . . . . . 107
6.4 External robots spying the structure . . . . . . . . . . . . . . . . . . . . . . . 107
6.5 An intruder transmits wrong coordinates to its neighbours . . . . . . . . . . . 108

164 LIST OF FIGURES
6.6 Functional scheme of the first phase of version 2 . . . . . . . . . . . . . . . . 111
6.7 Encrypted communications between 2 nanobots . . . . . . . . . . . . . . . . . 111
6.8 Refined version of phase 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
6.9 Conflict resolution in three steps against a malicious robot (a) and with a
friendly robot (b). Blue modules represent a friendly robot in movement. Red
modules represent malicious modules. The desired new place of a module is
depicted by dotted module and a dashed arrow. When messages are authenti-
cated, they are represented by thick blue arrows or thick red arrows if otherwise.
The blue Shields represent a secured interface. . . . . . . . . . . . . . . . . . . 115
6.10 Functional scheme of the ciphered communications during the second phase . . 116
6.11 Neighbours interactions following the version three of the protocol . . . . . . . 117
6.12 Phase 1 of version 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
6.13 Sequence diagram of the authentication phase in V4 . . . . . . . . . . . . . . 119
6.14 Authentication approach when modules are moving and connecting to new
neighbours: 1) When A decides to move and connect to C, it will inform B about
its movement and sends its ID with the message; 2) B, by its turn, will inform
C that A is coming to connect to it and forwards A’s ID as well; 3) Whenever
A accomplishes its movement, it will input its ID into the chaotic function and
sends the result obtained to C; 4) C will input the obtained ID from B, process it
in the chaotic function and compares the results. If both results are matching,
then the connection authenticated; The new position of module A is depicted
by the dotted module. The dashed arrow represents the movement that will
be made by A. Yellow arrows means a normal communication and message
exchange. Red arrow means that the module is asking for authentication and
green arrow depicts the approval of the authentication . . . . . . . . . . . . . 120
6.15 Self-assessment of the 4 proposed protocols through CEI criteria . . . . . . . . 122
6.16 Crossed analysis of ECRYPT II figures . . . . . . . . . . . . . . . . . . . . . . 125
6.17 Encryption process of HIGHT Shirai et al. (2007) . . . . . . . . . . . . . . . . 126
6.18 Six different ways to turn a block cipher to a hash function Black et al. (2002).
M is the block of data to hash that has been divided into the parts noted mi; hi
is the result of a hash turn, h0 is a constant arbitrarily chosen and the central
block is the encryption algorithm. The latter is used i times based on one of
the models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
6.19 Using the HEIGH algorithm for encryption and hashing simultaneously . . . . . 129
LIST OF FIGURES 165
6.20 Simulation graph. The initial module is colored in yellow. The bots that
are trying to authenticate are in white and numbered 1 and 2. After the
authentication phase, module 1 is authenticated, therefore, it is now colored in
yellow. Module 2 in rejected, therefore it is colored in red. . . . . . . . . . . . 130
6.21 Comparison of two cases, a) and b) has the same blue and green trees but b)
has yellow modules in addition. In the case b), yellow tree will dramatically
change the results. The yellow tree will be loosing against the blue tree, and it
will be then merged into one tree. So in this case having two identical trees is
not considered as a collision. . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
List of Tables
2.1 Characteristics for different types of modular robots. . . . . . . . . . . . . . . 30
3.1 Comparison of all leader election algorithms . . . . . . . . . . . . . . . . . . . 48
3.2 Interface status . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.1 Performance Evaluation for the whole algorithm on different versions of the
modules structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
5.1 Interface status . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
6.1 Comparison among different technologies. . . . . . . . . . . . . . . . . . . . . 105
6.2 EBIOS risk assessment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
6.3 Cryptanalysis results for the HIGHT algorithm . . . . . . . . . . . . . . . . . . 129
6.4 Different messages type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
6.5 Variables used in the simulation and their values . . . . . . . . . . . . . . . . . 130
167
List of Definitions
1 Definition: Particle/module . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2 Definition: Weight . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3 Definition: Symmetrical system . . . . . . . . . . . . . . . . . . . . . . . . . . 10
4 Definition: Anonymity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
5 Definition: Identical modules . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
6 Definition: Fixed memory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
7 Definition: Fixed connection of a module with its neighbors . . . . . . . . . . . 10
8 Definition: Joint internal clock . . . . . . . . . . . . . . . . . . . . . . . . . . 10
9 Definition: Peer to peer communication by contact . . . . . . . . . . . . . . . 11
10 Definition: Leader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
11 Definition: Connected Modules . . . . . . . . . . . . . . . . . . . . . . . . . . 11
12 Definition: Partial disconnection . . . . . . . . . . . . . . . . . . . . . . . . . 90
13 Definition: Complete disconnection . . . . . . . . . . . . . . . . . . . . . . . . 90
14 Definition: Lattice architecture . . . . . . . . . . . . . . . . . . . . . . . . . . 90
15 Definition: Density . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
16 Definition: Potential neighbors . . . . . . . . . . . . . . . . . . . . . . . . . . 91
169
Document generated with LATEX and:
the LATEX style for PhD Thesis created by S. Galland — http://www.multiagent.fr/ThesisStyle
the tex-upmethodology package suite — http://www.arakhne.org/tex-upmethodology/
écol e doct oral e sci ences pour l ’i ngéni eur et mi crotechni ques
Title: Leader election and fault detection for secured self-reconfigurable modular robots
Keywords: Programmable Matter, Distributed Algorithms, Modular Robotics, Self-reconfiguration, Multi-agent Systems
Abstract:
Recent advancements in science foreshadow that in the lead to collisions among modules. To solve this problem, a
next few decades it might be possible to assemble reconfiguration algorithm is created based on virtual forces.
simple information processing units at almost no cost. This algorithm tackles the self-reconfiguration problem by
Myriads of these small-scale units could be combined to presenting a deterministic planning algorithm that can decide
powerful systems capable of solving intricate tasks, this which positions can be filled over multiple iterations using
is called programmable matter. This vision of building virtual forces. To detect errors in programmable matter
cheap microscopic processing units is supported by the systems, an error detection algorithm called DETECTOR is
progress made in manufacturing microelectro mechanical proposed. It is a hierarchically distributed fault detection
components, such that one can anticipate integrating logic algorithm, it allows the detection of disconnections in a
circuits, microsensors, microactuators, and communication hierarchical manner. The leader of the system will construct
devices on the same chip. the spanning tree, assign coordinates to each module and
This thesis presents four algorithms that propose a solution compare them to detect the disconnections. And finally, to
to four of the main issues in programmable matter: Leader ensure security in programmable matter, a security protocol
election, reconfiguration, error detection, and security. The is developed to solve the issue. This protocol is based
leader election algorithm deterministically elects a leader in a on lightweight cryptography and uses the same encryption
modular robotic system regardless of the modules’ type and protocol as a hashing function while keeping the distributed
configuration. The reconfiguration problem occurs when too architecture in mind. The analysis and simulation results
many particles are moving at the same time. This might show the efficiency of the proposed method.
Titre : Election de leader et détection de fautes pour robots modulaires sécurisés et auto-reconfigurables
Mots-clés : Matière Programmable, Algorithmes Distribués, Robotique Modulaire, Autoreconfiguration, Systèmes Multi-
agents
Résumé :
Les récents progrès de la science laissent présager collisions entre les modules. Pour résoudre ce problème,
que, dans les prochaines décennies, il pourrait être un algorithme de reconfiguration basé sur les forces
possible d’assembler des unités simples de traitement de virtuelles est créé. Cet algorithme s’attaque au problème
l’information pour un coût presque nul. Des myriades de l’auto-reconfiguration en présentant un algorithme
de ces petites unités pourraient être combinées pour de planification déterministe qui peut décider quelles
former des systèmes puissants capables de résoudre positions peuvent être remplies sur plusieurs itérations
des tâches complexes. Cette vision de la construction en utilisant des forces virtuelles. Pour détecter les
d’unités de traitement microscopiques bon marché est erreurs dans les systèmes de matière programmable, un
soutenue par les progrès réalisés dans la fabrication algorithme de détection d’erreurs appelé DETECTOR
de composants microélectro mécaniques, de sorte que est proposé. C’est un algorithme de détection de fautes
l’on peut envisager d’intégrer des circuits logiques, des distribué hiérarchiquement, il permet de détecter les
microcapteurs, des microactionneurs et des dispositifs déconnexions de manière hiérarchique. Le leader du
de communication sur la même puce. système va construire l’arbre de recouvrement, attribuer
Cette thèse présente quatre algorithmes qui proposent des coordonnées à chaque module et les comparer pour
des solutions à quatre des principaux problèmes de détecter les déconnexions. Et enfin, pour assurer la
la matière programmable : l’élection du leader, sécurité dans la matière programmable, un protocole
la reconfiguration, la détection des erreurs et la de sécurité est développé pour résoudre le problème.
sécurité. L’algorithme d’élection du leader élit de Ce protocole est basé sur la cryptographie légère et
manière déterministe un leader dans un système utilise le même protocole de cryptage comme fonction
robotique modulaire, indépendamment du type et de hachage tout en gardant à l’esprit l’architecture
de la configuration des modules. Le problème de distribuée. Les résultats d’analyse et de simulation
reconfiguration se produit lorsque trop de particules se montrent l’efficacité de la méthode proposée.
déplacent en même temps. Cela peut entraı̂ner des
Université Bourgogne Franche-Comté

32, avenue de l’Observatoire
25000 Besançon, France

These Edy Hourany

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

These Edy Hourany

Uploaded by

Copyright:

Available Formats

THÈSE DE DOCTORAT

DE L’ÉTABLISSEMENT UNIVERSITÉ BOURGOGNE FRANCHE-COMTÉ

PRÉPARÉE À L’UNIVERSITÉ DE FRANCHE-COMTÉ

École doctorale n°37

Sciences Pour l’Ingénieur et Microtechniques

Thèse présentée et soutenue à Montbéliard, le 13 decembre 2022

• AIM: Assembly Incidence Matrix. 31

• CCW: Counter Clock Wise. 73–76, 82

• CW: Clock Wise. 73–76, 82

• DOF: Degree Of Freedom. 15, 21, 23, 30

• FCC: Face Centered Cubic. 72

• GA: Genetic Algorithm. 16, 35, 37

• MRR: Modular Reconfigurable Systems. 89

• MRTP: Modular Robot Time Protocol. 7, 8

• PMS: Programmable Matter Systems. 2–4, 12, 102

• SMORES: Self-assembling Modular Robot for Extreme Shapeshifting. 27

• VF: Virtual Forces. 76, 82, 162

• VFA: Virtual Force Algorithm. 70, 71, 75, 134

• WSN: Wireless sensor network. 134

1.1 Research Context . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

1.2 Motivation and inspiration . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1.2.1 Functional advantage . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1.2.2 Economic advantage . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

1.3 Background Description and Definitions . . . . . . . . . . . . . . . . . . . . . 6

1.3.1 Blinky Blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2 Modular Robots Generalities 13

2.2 History and Architecture of Modular Robots . . . . . . . . . . . . . . . . . . . 15

2.2.2 Connections and Network . . . . . . . . . . . . . . . . . . . . . . . . . 18

2.2.6 Multiple types of robots . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2.3 Modular Robots Characteristic . . . . . . . . . . . . . . . . . . . . . . . . . . 30

2.4 Application area . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

2.4.1 Space exploration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

2.4.3 Bucket of stuff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

2.4.4 Medical Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

2.5.7 Leader Election . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

2.6 Ethics in Modular Robots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

2.7 Simulation Environment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

3.1.1 Existing Leader election algorithms . . . . . . . . . . . . . . . . . . . . 46

3.2 Proposed algorithm and contribution . . . . . . . . . . . . . . . . . . . . . . . 48

3.2.1 Computing the weight parameter . . . . . . . . . . . . . . . . . . . . . 49

3.2.2 Recruitment phase . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

3.2.3 Tree value computation . . . . . . . . . . . . . . . . . . . . . . . . . . 51

3.2.4 Competition with other trees . . . . . . . . . . . . . . . . . . . . . . . 53

3.2.5 Dismantling trees and more recruitment . . . . . . . . . . . . . . . . . 55

3.2.6 Leader election phase . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

3.3 Termination with no Leader . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

3.4 Complexity analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

3.4.1 Theoretical analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

3.4.2 Empirical analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

4 Reconfiguration using virtual forces 69

4.2 Literature Review . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

4.4 Proposed Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

4.4.1 Distributed Virtual Force Algorithm (VFA) . . . . . . . . . . . . . . . . 75

4.5 Simulation Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

5.3 Detector: disconnection detection . . . . . . . . . . . . . . . . . . . . . . . . 89

5.3.2 The Proposed Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . 92

5.4 Simulation Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

5.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

6.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

6.2 Background Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

6.2.1 Lightweight cryptography . . . . . . . . . . . . . . . . . . . . . . . . . 103

6.2.2 Hardware consideration . . . . . . . . . . . . . . . . . . . . . . . . . . 105