Conference PaperPDF Available

Distributed Computation of Forces in Modular-Robotic Ensembles As Part of Reconfiguration Planning

Abstract

We discuss selected mechanical aspects of self-reconfiguration of densely-packed modular robots. The change of connection topology and transport of modules are fundamental mechanisms for these systems, which determine their desired emergent behavior, e.g., movement, shape change or interaction with their surroundings. At the same time, reconfiguration affects the forces between modules. We present a distributed procedure by which a robot can predict if the next planned reconfiguration step will overstress intermodular connections. We use a Finite Element model of a modular robot, with one-node-per-module discretization and beam elements representing intermodular connections. The analysis is restricted to static loads and linear elasticity. We present a distributed procedure of aggregation of the stiffness matrix and iterative solution of the resulting equations of elasticity. The procedure is illustrated with numerical examples and analyzed in terms of its efficiency.
Distributed computation of forces in modular-robotic ensembles as part
of reconfiguration planning*
Paweł Hołobut and Jakub Lengiewicz
Abstract We discuss selected mechanical aspects of self-
reconfiguration of densely-packed modular robots. The change
of connection topology and transport of modules are fundamen-
tal mechanisms for these systems, which determine their desired
emergent behavior, e.g., movement, shape change or interaction
with their surroundings. At the same time, reconfiguration
affects the forces between modules. We present a distributed
procedure by which a robot can predict if the next planned
reconfiguration step will overstress intermodular connections.
We use a Finite Element model of a modular robot, with one-
node-per-module discretization and beam elements representing
intermodular connections. The analysis is restricted to static
loads and linear elasticity. We present a distributed procedure
of aggregation of the stiffness matrix and iterative solution of
the resulting equations of elasticity. The procedure is illustrated
with numerical examples and analyzed in terms of its efficiency.
I. INTRODUCTION
Self-reconfigurable robots are built of robotic units—
modules—which can attach to each other, move relative
to one another, sense environmental stimuli, compute, and
communicate [1], [2]. Among them there is a class of
densely-packed systems, which includes lattice-based robots,
whose modules are arranged on a regular grid, and the
futuristic concept of Programmable Matter [3], [4]. Densely-
packed robots are built of large numbers of small modules
which together fill a volume. They move and change shape
mostly through varying the connection topology of their
modules—connections between some modules are released,
free modules move to new locations, and then new connec-
tions are formed. A repeated sequence of this kind, with
modules “flowing” to new locations, transforms a robot from
one shape into another.
Designing procedures which make a robot transition from
one shape into another, be it for locomotion or for its own
sake, is a well explored topic. Example solutions include col-
lective movement on the ground [5], [6], and reconfiguration
using metamodules [7], hole motion [8], a scaffolding and
attraction gradients [9], and by tunneling modules through
the structure [10]. All these methods, and many others,
treat modular robots as purely geometric objects. During
reconfiguration, it is expected that the modules do not overlap
and that the robot remains connected, and also that individ-
ual modules obey certain procedure-specific local rules of
*This work was partially supported by the project “Micromechanics
of Programmable Matter” (contract no. 2011/03/D/ST8/04089 with the
National Science Centre in Poland)
Jakub Lengiewicz and Paweł Hołobut are with the Institute of Fundamen-
tal Technological Research, Polish Academy of Sciences, Warsaw, Poland
jleng@ippt.pan.pl, pholob@ippt.pan.pl
motion. However, the fact that modular robots are physical
systems is not addressed—the forces between modules may
exceed the strength of intermodular connections, or the
entire structure may lose balance and collapse. (Stresses in a
special class of modular structures have been investigated
in [11], [12].) Inclusion of these mechanical factors into
reconfiguration planning would be essential in practice.
Computation of deformation and stresses is a well-
developed area of mechanical and structural engineering. If
an adequate mechanical model of a robot and its environment
is developed, then one may predict intermodular and support
forces for any configuration of the robot. Thereby it can be
decided in advance if a planned reconfiguration sequence is
mechanically feasible or not. The Finite Element Method
(FEM) [13] and related spring-mass discretization methods
are the most widely used techniques of mechanical analysis.
An approach of this kind has already been employed to study
mechanical properties of modular structures in [14]. The
authors developed a simplified methodology for assessing the
compliance of fixed-topology modular structures, in order to
aid the process of optimizing modular tools for a given task.
They assigned 6 degrees of freedom (DOF) to each module,
and introduced stiffness matrices binding DOF of neigh-
bor modules to represent intermodular connections. Their
MATLAB-based simulator used a centralized numerical pro-
cedure to solve the resulting system of equations of statics
under a given load. A similar approach, but extended to
dynamics, has been proposed in [15] and further expounded
in [16]. The authors developed a simulator for voxelized
soft matter, potentially produced by additive manufacturing.
They represented each voxel by a mass point with a moment
of inertia, and bound neighbor points with elastic beams to
emulate the elastic properties of the modeled material. The
simulator used a centralized, forward-stepping Euler scheme
to integrate the resulting system of equations of motion.
We present a distributed procedure by which a modular
robot can verify the mechanical feasibility of its planned
reconfiguration one step ahead. It follows the ideas of [3]
and [17], and is a synthesis of three components. The
first one is the method of simplified modeling of modules
and their connections proposed in [14] and [15], [16]. The
second one is the iterative solution of systems of (linear)
equations on Multiple Instruction Multiple Data (MIMD)
parallel computing architectures [18], [19], of which modular
robots are examples. The third one is the separation of the
reconfiguration process into elementary steps which can be
effectively mechanically analyzed on a distributed computa-
tional medium, exploiting its connection topology. The main
IEEE International Conference on Robotics and Automation (ICRA 2017), May 29 -- June 3, 2017, Singapore (corrected)
difference between the present work and [14], [15], [16] is
that we explicitly address self-reconfiguration of modular
robots, and that our procedure is aimed at being executed
by the modular robot itself in a distributed fashion.
II. DESCRIPTION OF THE PROBLEM
A. Model of the robot
We consider modular robots of arbitrary spatial structure
and abstract from any particular geometry of modules. (In
figures, robots will be planar and usually arranged on a
square grid, while modules will be spheres; this choice is
arbitrary and done for convenience.) Such robots can be
represented as undirected graphs, cf. Fig. 1a, with vertices
representing modules and edges representing connections. In
these graphs, however, distances and angles correspond to the
real geometry of the robot. We do not impose any restrictions
on the number of connections that a module can form, nor
on their spatial arrangement. For example, there may be up
to six regularly-arranged nearest-neighbor connections for a
cubic module, or up to twelve freely-arranged connections
for a spherical module. There are many other cases and the
procedure below can address them all. We assume that:
Modules can communicate with their neighbors; in
particular, connected modules can communicate.
Modules can store information and compute.
Modules can move (only) when connected to other
modules.
Modules can attach to and detach from their neighbors.
The strength of connections is lower than the strength
of module bodies.
Modules know the positions of their neighbors.
Modules know their own orientations in a global co-
ordinate system (like xyz in Fig. 1; we disregard the
orientation-detection problems discussed in [20]).
Modules know (can sense or have a good model of)
forces acting on them.
In the analysis below we shall also assume that the forces of
inertia are small compared with gravity and external loading.
This amounts to assuming that modules move slowly, or
that relatively few modules move at once, or both. We thus
neglect dynamics and focus on statics.
B. Reconfiguration steps
Reconfiguration of modular robots can be approximately
considered a discrete process. Assuming fast creation/release
of connections, the change of connection topology of a finite
robot proceeds in steps, as is illustrated in Fig. 1. The first
step is the release of some existing connections by one or
more modules which are about to move (active modules). In
Fig. 1b, the red modules 3 and 5 release all their connections
except the ones with module 6, about which they will rotate.
The second step is the parallel movement of active modules
until a new module-module contact is made, like between
the pair 3-10 in Fig. 1c. The last step is the formation of
new connections, like 5-3 and 3-10 in Fig. 1d. Repetition of
these steps constitutes reconfiguration.
Remark Some steps in the sequence may be omitted. For
example, when a module releases a connection with one
neighbor and immediately thereafter forms a connection with
another neighbor, without moving in between.
C. Mechanical feasibility of reconfiguration
There are two types of mechanical failure, shown in
Fig. 2, which should be addressed when doing an analysis
of reconfiguration. The first one is the loss of stability by a
structure and its fall, which involves motion of the robot as a
rigid body. This situation may be induced by the movement
of modules during reconfiguration (phase b–c in Fig. 1)
and the resulting shift of the robot’s center of mass. The
second one is the possibility of forced bond breaking between
connected modules—caused by overloading and excessive
stresses. This situation is related to elastic deformations of
the robot under load and may result from the release-of-
connections step of reconfiguration (phase a–b in Fig. 1) and
the ensuing decrease of the overall strength of the robot.
Remark The formation-of-new-connections phase of re-
configuration (phase c–d in Fig. 1) is not potentially dam-
aging, as it can only increase the stiffness and strength of a
structure.
The first kind of failure is illustrated in Fig. 2b. Modules
1–5 of Fig. 2a simultaneously release their connections with
each other and move one module-width to the left. As
a result, the structure loses balance about its support and
falls around module 16. A movement of this kind may be
intentional, as part of a robot’s planned motion, or not. In
either case, the system should be able to predict this situation
before it occurs. We will not further discuss this problem in
the current paper. We only note that it may be collectively
resolved by the system by
1) determining the convex hull of the system’s points of
support one step ahead,
2) computing the resultant force acting on the system and
its point of attachment—one step ahead,
3) checking if the force vector aims, from its point of
attachment, at the interior of the convex hull.
The whole operation is based on aggregating information
from the entire ensemble.
The second kind of failure is illustrated in Fig. 2c. Modules
3 and 8 prepare to move upwards and release connections 2-
3, 7-8, 3-8, and 8-13. As a result, the left part of the structure
is only supported by the connection 12-13, which becomes
overstressed. Distributed prediction by the system of this type
of failure, before the reconfiguration step is actually made, is
discussed in the rest of the paper. The problem we consider
is a problem of verification, which may also be made a part
of planning, and can be stated as follows:
The system reconfigures following a plan designed by an
independent procedure. The next planned step of reconfigu-
ration involves releasing a particular set of current connec-
tions. The problem for the system is to compute whether this
operation will not overstress the remaining connections, as
such an event may be irreversible.
(a) (b) (c) (d)
Fig. 1. Modular robot as a graph (a), and three reconfiguration steps: (b) release of some connections by the modules which are about to move (active
modules)—here modules 3 and 5, shown in red; (c) movement of active modules to new locations; (d) formation of new connections by the active modules.
(a) (b) (c)
Fig. 2. Mechanical failures during reconfiguration: (a) initial system, (b) instability about the support (at module 16), and (c) overstressed connection
(between modules 12 and 13, in red). Black rectangles between modules denote existing connections; gravity is assumed to act down the page.
III. ALGORITHMIC MECHANICAL ANALYSIS
A. Finite Element representation of modules and connections
For simplicity, we assume that the inter-modular connec-
tion follows the standard linear beam model, provided below,
see e.g. [14], [16], and also [21] for the general theory. With
moderate effort, the presented methodology can be adjusted
to work with different models.
In the beam model, each module is represented by 6 DOF
in 3D (or 3 DOF in 2D) localized at a distinct point (a node).
The three first DOF are displacements and the remaining
three are rotations (in 2D there are two displacement- and
one rotational DOF). The action of a module Mpon a
neighboring module Mqis expressed by the relationship
fpq =K11
pqup+K12
pquq(1)
between the vector of generalized elastic forces fpq and
the vectors of generalized displacements up,uq. Without
losing generality, to keep the notation compact, further on we
restrict ourselves to 2D. The vectors for the module Mpthen
read fpq = (fpq,x, fpq ,y, fpq,θ )and up= (up,x, up,y , up,θ),
and the stiffness sub-matrices for horizontally-aligned mod-
ules Mpand Mqare
K11
pq =E
L3
AL20 0
0 12I6IL
0 6IL 4IL2
,(2)
K12
pq =E
L3
AL20 0
012I6IL
06IL 2IL2
,(3)
where E,L,Aand Iare elastic modulus, length, cross-
sectional area and area moment of interia of the beam
Fig. 3. Initial, loaded, and perturbed configuration.
connection, respectively. Note also that for an arbitrarily
oriented pair of modules the stiffness matrices must be
appropriately re-oriented.
The ensemble is in the static balance if for each module p
the sum of reaction forces with its neighbors fp=Pqfpq
is equal to the external force Fpacting on that module. This
can be expressed as the following set of equations
p"X
q
K11
pqup+K12
pquq#=Fp.(4)
for unknown displacements up. After assembling appropriate
global vectors uand F, and matrix K, Eq. (4) takes the
familiar form
Ku =F.(5)
Remark In order to introduce the necessary displacement
boundary conditions, it is enough just to remove the restricted
DOF from the system of equations (5).
B. Outline of the algorithm
In the presented framework we distinguish three configu-
rations: unloaded , loaded ω, and perturbed ¯ω; see Fig. 3.
The loaded configuration represents the actual state of the
modular system and the perturbed configuration is the state of
the system to be predicted by the ensemble. Here we assume
that the analyzed perturbation is due to either releasing
some number of intermodular connections, i.e., K¯
K,
or modifying the external loading, i.e., F¯
F. The first
type of perturbation just removes the intermodular stiffness;
therefore, for a given pair pq of modules we get
K11
pq =K12
pq =K11
qp =K12
qp =0.(6)
After the (virtual) perturbation, the system is in general
no longer in static balance. In order to predict its state it is
necessary to solve the following problem
¯
K¯
u=¯
F,(7)
for the total displacement ¯
u.
The displacement ¯
ucan be split into the sum of the current
displacement uand its increment ¯
udue to the perturbation.
Making use of the assumed linearity of the model, after
rearrangements and switching to the node-wise form we get
p"X
q
¯
K11
pq¯
up+¯
K12
pq¯
uq#=¯
FpX
q
¯
fpq,(8)
where
¯
fpq =fpq if connection persists
0if connection is released .(9)
The form (8) might be particularly suitable if the modules
could physically measure and store the connection forces
fpq. In that case, the unknowns are the increments ¯
u;
therefore the solution to the perturbed system could be
potentially less time-consuming because the calculation starts
at the deformed configuration.
Remark In Eq. (9) we have assumed that when two neigh-
bor modules release their connection, any elastic interaction
between them disappears. This assumption is equivalent to
the postulate that when a bond is released a gap between
modules arises, which is large enough to allow them to freely
approach each other without colliding. This is certainly not
true for all reconfiguration scenarios, connection types, and
module geometries. In many cases, including electrostatic
and magnetic connections, releasing a connection allows
modules to be separated, but does not allow them to get
closer. In these cases, releasing a connection produces a
unilateral contact constraint, which must be dealt with by
an appropriate non-symmetric interaction model. A similar
situation occurs in the case of module-environment interac-
tions, where displacement constraints are also frequently of
the one-sided contact type. We do not further discuss these
problems in the current paper. We only note that they can be
addressed by suitably adapting the current methodology, and
possibly—on the hardware side—by equipping modules with
proximity sensors when dealing with large deformations.
C. Distributed solution of the linear problem
The system of equations (7) or (8) needs to be solved
by a modular robot itself. Such a robotic system can be
classified as a Multiple Instruction Multiple Data (MIMD)
parallel computing architecture, see [18], [19], and there
exist a number of iterative solution methods suitable for such
architectures. Here, we employ one of the simplest solution
schemes, the weighted Jacobi method, as a demonstration of
the idea. The advantage of the Jacobi method is its simplicity
and the fact that it only uses local information.
For the system of equation (8), for each module p, a single
iteration of the weighted Jacobi method reads
¯
ui+1
p=β¯
Dp
1 ¯
Fp¯
fp¯
Rp¯
ui
pX
q
¯
K12
pq¯
ui
q!
+(1 β)∆¯
ui
p,(10)
where β= 2/3and
¯
Dp=diag X
q
¯
K11
pq!and ¯
Rp= X
q
¯
K11
pq!¯
Dp
are the diagonal and the remainder part of the respective
stiffness sub-matrices. Initially, ¯
u0
p=0.
One can easily see that in the iteration step (10) it is only
necessary for a given module to know its own displacements
and the displacements of its direct neighbors, all from the
previous iteration. Because of this, the algorithm can be run
in parallel, and the synchronization is easily assured as the
next iteration is performed not earlier than when the module
receives current displacements from all its direct neighbors.
Remark The choice of a suitable halting criterion for
the provided distributed algorithm is not a straightforward
task. The calculations should not stop earlier than when the
system is in balance to a desired precision. Locally, one can
easily check the balance of forces at each individual module
and analyze the increments of displacements. However, the
overall decision to stop can not be made locally. This is
because relatively small local deviations from balance can
accumulate to a larger effect. Therefore, the decision must
be somehow negotiated (synchronized) across the robot. This
problem is not analyzed in the present work and is left for
further research.
D. Criteria of bond failure
Once equations (7) are solved by the system, the vectors
of predicted local forces fpq and fqp are known by each pair
of connected modules Mpand Mq. Assuming that the beam
model of connected modules is reasonably accurate, one can
use these predictions to check if the connection will hold. We
will give a simple 2D example of two horizontally-aligned
square modules Mpand Mq:, bound by magnetic (or
electrostatic) forces. The forces and the bending moment in
the beam should not exceed the junction’s capacity. Namely:
the axial force must be lower than the magnets’ holding
force fm:fpq,x =fqp,x < fm, where fpq,x >0when
the beam is compressed;
the shear force must be lower than the threshold of
friction: |fpq,y |=|fqp,y |< µ(fm+fpq,x ), with µbeing
the friction coefficient of the modules’ surfaces;
the bending moment in the beam must be lower than
the torque produced by the magnets about a module’s
corner: max(|fpq,θ |,|fqp,θ |)<(fm+fpq,x )·l/2, with
lbeing the side-length of a module.
If the above conditions are satisfied, one may expect the
junction to hold. Otherwise it may fail. For different types
of junctions and different module geometries, other case-
specific failure criteria may have to be used.
IV. NUMERICAL EXAMPLES
The framework presented in Section III has been im-
plemented in the Wolfram Mathematica environment. The
results obtained by the iterative weighted Jacobi method have
been successfully verified against the solution obtained by
simply assembling the global stiffness matrix and solving the
global system of equations by a standard direct solver. Two
basic problems have been analyzed in order to present how
this approach could work in practice, and also to validate the
algorithm and to check its basic properties.
The following specific parameters of the model have been
used in the examples:
E= 1 [MPa],L= 4 [mm],
A= 1 [mm2],I= 1/12 [mm4].
Problem 1 is a modular robot that forms a horizontal
cantilever, with the modules on its right side fixed, cf. Fig. 4.
Similarly, in Problem 2, the robot forms a shape with holes
with its top layer of modules fixed, cf. Fig. 5. Both robots
are loaded by their own masses in the gravitational field
(assumed mass of a single module m= 4 ×106[kg]). The
robots want to check what will happen if certain intermodular
connections are released, in particular whether the remaining
connections will not be overloaded. The calculated solution
for Problem 1, see Figs. 6 and 7, shows a significant
increase of both axial and shear forces (red color), with
visible localization of tensile axial forces at the opening tip,
which might cause a collapse of the robot. Note however,
that to some extent this could have been predicted a’priori,
because some of the released connections were transmitting
significant tensile forces. It was not the case for Problem 2,
for which the axial and shear loads in the non-perturbed
configuration are relatively low and it would be difficult to
detect a’priori the connections that should not be released.
In the calculated solution, see Figs. 8 and 9, high tensile
axial and shear forces can be observed because the forces
were magnified by the lever that was formed after the
reconfiguration.
In order to check the convergence properties of the iter-
ative scheme, the initial loading phase of Problem 1 (i.e.,
from gray to red configurations in Fig. 4) was run for
three different numbers of modules reconstructing the same
problem, i.e., the original 7×15 size, and two reduced
sizes of 4×8and 2×4modules, respectively. The loading
conditions were so adjusted as to keep the deformation
similar for the three cases, i.e., for the medium size the
modules’ masses were doubled and for the smallest size
they were quadrupled. The convergence was analyzed in
Fig. 4. Problem 1. Unloaded (gray), loaded (red), and modified (blue)
configurations. Deformation amplified 5×for better visibility.
Fig. 5. Problem 2. Unloaded (gray), loaded (red), and modified (blue)
configurations.
terms of the relative error, taken with respect to the exact
solution. Fig. 10 shows the dynamics of the convergence
with increasing number of iterations for the three different
analyzed cases. One can see that a tolerable relative error
(five percent) is attained at the cost of a very high number
of iterations. Moreover, the number of iterations quickly
increases with the number of modules, which is cumulatively
shown in Fig. 11. This should be viewed as a drawback of
the method and a motivation to search for a better strategy.
V. CONCLUSIONS
The present procedure is only a minor addition to au-
tonomous reconfiguration planning. Still, we believe it is
the first that includes the analysis of local mechanical
interactions between modules in a distributed fashion. It
has drawbacks and limitations, which are either inherent or
introduced in exchange for simplicity. We comment on three
of them below.
Firstly, the procedure does only one-step-ahead checking
as opposed to planning. It can prevent a catastrophic recon-
figuration step, but is otherwise unconstructive. It would be
Fig. 6. Problem 1. Axial forces for the deformed physical configuration (left) and predicted axial forces for the modified configuration (right). Deformation
amplified 5×for better visibility.
Fig. 7. Problem 1. Shear forces for the deformed physical configuration (left) and predicted shear forces for the modified configuration (right). Deformation
amplified 5×for better visibility.
Fig. 8. Problem 2. Axial forces for the deformed physical configuration (left) and predicted axial forces for the modified configuration (right).
desirable to adapt it for longer-range prediction, or utilize
the short-range results for optimizing reconfiguration.
Secondly, the Jacobi-type iterative procedure is inefficient.
It was chosen because of its conceptual simplicity and lo-
calized data-storage and communication requirements. Well-
parallelized Krylov Subspace Methods can be expected to
be more efficient. However, it may also turn out that real
efficiency for large-ensemble systems can only be achieved
through averaging and DOF reduction.
Finally, we used a simple linear beam model of connec-
tions between modules. This may be insufficient to accurately
represent real connections. If more involved, unsymmetric
interactions between modules were included, a different
distributed solution procedure might be required.
REFERENCES
[1] K. Støy, “Emergent control of self-reconfigurable robots,” Ph.D.
dissertation, The Maersk Mc-Kinney Moller Institute for Production
Technology, University of Southern Denmark, Odense, Denmark,
2004.
Fig. 9. Problem 2. Shear forces for the deformed physical configuration (left) and predicted shear forces for the modified configuration (right).
Nnod=8
Nnod=32
Nnod=105
0 5000 10 000 15 000 20 000 25 000 30 000
0.0
0.2
0.4
0.6
0.8
1.0
Number of iterations
Relative error
Fig. 10. Convergence of the weighted Jacobi iterative procedure for
different numbers of modules.
20 40 60 80 100
0
5000
10 000
15 000
20 000
25 000
30 000
Number of modules
Number of iterations
Fig. 11. Convergence analysis. Number of iterations needed to attain a
5% relative error for an increasing number of modules.
[2] M. Yim, W.-M. Shen, B. Salemi, D. Rus, M. Moll, H. Lipson,
E. Klavins, and G. S. Chirikjian, “Modular self-reconfigurable robot
systems,” IEEE Robotics and Automation Magazine, vol. 14, no. 1,
pp. 43–52, 2007.
[3] T. Toffoli and N. Margolus, “Programmable matter: concepts and
realization,” Physica D, vol. 47, no. 1–2, pp. 263–272, 1991.
[4] S. C. Goldstein, J. D. Campbell, and T. C. Mowry, “Programmable
matter,IEEE Computer, vol. 38, no. 6, pp. 99–101, 2005.
[5] Z. Butler, K. Kotay, D. Rus, and K. Tomita, “Generic decentral-
ized control for lattice-based self-reconfigurable robots,” International
Journal of Robotics Research, vol. 23, no. 9, pp. 919–937, 2004.
[6] R. Fitch and Z. Butler, “Million module march: scalable locomotion
for large self-reconfiguring robots,” International Journal of Robotics
Research, vol. 27, no. 3–4, pp. 331–343, 2008.
[7] P. Bhat, J. Kuffner, S. C. Goldstein, and S. Srinivasa, “Hierarchical
motion planning for self-reconfigurable modular robots,” in Proceed-
ings of the IEEE/RSJ International Conference on Intelligent Robots
and Systems, 2006, pp. 886–891.
[8] M. De Rosa, S. C. Goldstein, P. Lee, J. Campbell, and P. Pillai,
“Scalable shape sculpting via hole motion: motion planning in lattice-
constrained modular robots,” in Proceedings of the IEEE International
Conference on Robotics and Automation, 2006, pp. 1462–1468.
[9] K. Støy, “Using cellular automata and gradients to control self-
reconfiguration,” Robotics and Autonomous Systems, vol. 54, no. 2,
pp. 135–141, 2006.
[10] Z. Butler and D. Rus, “Distributed planning and control for modular
robots with unit-compressible modules,” International Journal of
Robotics Research, vol. 22, no. 9, pp. 699–715, 2003.
[11] P. Hołobut, M. Kursa, and J. Lengiewicz, “A class of microstructures
for scalable collective actuation of Programmable Matter,” in Proceed-
ings of the IEEE/RSJ International Conference on Intelligent Robots
and Systems, 2014, pp. 3919–3925.
[12] J. Lengiewicz, M. Kursa, and P. Hołobut, “Modular-
robotic structures for scalable collective actuation,Robotica,
doi:10.1017/S026357471500082X, 2015.
[13] T. J. Hughes, The finite element method: linear static and dynamic
finite element analysis. Dover Publications, 2000.
[14] P. J. White, S. Revzen, C. E. Thorne, and M. Yim, “A general stiffness
model for programmable matter and modular robotic structures,”
Robotica, vol. 29, pp. 103–121, 2011.
[15] J. Hiller and H. Lipson, “Automatic design and manufacture of soft
robots,” IEEE Transactions on Robotics, vol. 28, no. 2, pp. 457–466,
2012.
[16] ——, “Dynamic simulation of soft multimaterial 3d-printed objects,”
Soft robotics, vol. 1, no. 1, pp. 88–101, 2014.
[17] O. O. Storaasli, S. W. Peebles, T. W. Crockett, J. D. Knott, and
L. Adams, “The finite element machine: an experiment in parallel
processing,” NASA, Tech. Rep., 1982.
[18] J. W. Demmel, M. T. Heath, and H. A. Van Der Vorst, “Parallel
numerical linear algebra,” Acta Numerica, vol. 2, pp. 111–197, 1993.
[19] Y. Saad, Iterative methods for sparse linear systems, 2nd ed. Society
for Industrial and Applied Mathematics, 2003.
[20] P. Hołobut, P. Chodkiewicz, A. Macios, and J. Lengiewicz, “Internal
localization algorithm based on relative positions for cubic-lattice
modular-robotic ensembles,” in Proceedings of the IEEE/RSJ Interna-
tional Conference on Intelligent Robots and Systems, 2016, pp. 3056–
3062.
[21] W. McGuire, R. Gallagher, and R. Ziemian, Matrix structural analysis,
2nd ed. Wiley, 1999.
... In the present paper, we develop the approach introduced in [16] much further into a more realistic framework. Arbitrary 3D structures are investigated, for which a linear-elastic FE model is again adopted, with the addition of unilateral contact conditions which represent interaction with the surroundings. ...
... Algorithmic prediction of two failure modes, shown in Fig. 1, will be analyzed, expanding on the ideas proposed in [16]. The first one is when addition of new blocks increases stresses at some inter-modular junctions beyond the holding capacity of connectors, as a result of which the structure breaks, Fig. 1a. ...
... Eq. (13) is solved iteratively using the weighted Jacobi scheme [16]. A single iteration i → i + 1 for module p reads: ...
Article
Full-text available
We present a distributed framework for predicting whether a planned reconfiguration step of a modular robot will mechanically overload the structure, causing it to break or lose stability under its own weight. The algorithm is executed by the modular robot itself and based on a distributed iterative solution of mechanical equilibrium equations derived from a simplified model of the robot. The model treats intermodular connections as beams and assumes no-sliding contact between the modules and the ground. We also provide a procedure for simplified instability detection. The algorithm is verified in the Programmable Matter simulator VisibleSim, and in real-life experiments on the modular robotic system Blinky Blocks.
... For any of such methods to be workable, however, additional constraints of mechanical nature have to be considered. In a real physical setting, with a limited connection strength between modules and under the action of gravity and possibly other external loadings, reconfiguration may fail for at least two mechanical reasons [12]. The first one is loss of stability: when the center of mass of a modular robot shifts during reconfiguration in such a way that the structure is thrown out of balance and falls. ...
... Prediction of mechanical failure requires performing a mechanical analysis of the reconfigured version of a modular robot before the reconfiguration actually occurs, using the methods of computational mechanics [12]. There are two ingredients of this process. ...
... In the present paper, the approach to mechanical failure prediction proposed in [12] is significantly improved. The Finite Element representation of the modular robot with linear-elastic beams modeling pairs of connected modules is used again, this time in the general 3D setting. ...
Conference Paper
Full-text available
Large-scale 3D autonomous self-reconfigurable modular robots are made of numerous interconnected robotic modules that operate in a close packing. The modules are assumed to have their own CPU and memory, and are only able to communicate with their direct neighbors. As such, the robots embody a special computing architecture: a distributed memory and distributed CPU system with a local message-passing interface. The modules can move and rearrange themselves changing the robot's connection topology. This may potentially cause mechanical failures (e.g., overloading of some inter-modular connections), which are irreversible and need to be detected in advance. In the present contribution, we further develop the idea of performing model-based detection of mechanical failures, posed in the form of balance equations solved by the modular robot itself in a distributed manner. A special implementation of the Conjugate Gradient iterative solution method is proposed and shown to greatly reduce the required number of iterations compared with the weighted Jacobi method used previously. The algorithm is verified in a virtual test bed-the VisibleSim emulator of the modular robot. The assessments of time-, CPU-, communication-and memory complexities of the proposed scheme are provided.
... Some researchers have recently shown interest in this problem. In (Hołobut et al., 2017), the authors mention two types of mechanical failures that can occur in a MSR: (1) loss of stability due to a shift in the center of mass of the system, which might be caused by the movement of modules; ...
... The configuration stability problem was mentioned in , in which the authors state that stability can be insured under a few conditions, and for reconfiguration on a small class of shapes that they call stem cells, thanks to UCM traveling through the volume of the structure. Besides, failures due to overstressed connectors are investigated in (Hołobut et al., 2017), where the authors present a distributed procedure for predicting if the next reconfiguration step will cause a structural failure. Ideally, procedures of this sort could be added to the planning process of self-reconfiguration algorithms so as to further constrain possible motions to mechanically safe ones exclusively. ...
... Besides, regarding the mechanical aspect of self-reconfiguration, we assume for now that all intermediate configurations are stable, as efficiently ensuring the mechanical stability of reconfiguration is an ongoing intractable problem (Hołobut et al., 2017). ...
Thesis
Full-text available
Humans have always been on a quest to master their environment. But with the arrival of our digital age, an emerging technology now stands as the ultimate tool for that purpose: Programmable Matter. While any form of matter that can be programmed to autonomously react to a stimulus would fit that label, its most promising substrate resides in modular robotic systems. Such robotic systems are composed of interconnected, autonomous, and computationally simple modules that must coordinate through their motions and communications to achieve a complex common goal. Such programmable matter technology could be used to realize tangible and interactive 3D display systems that could revolutionize the ways in which we interact with the virtual world. Large-scale modular robotic systems with up to hundreds of thousands of modules can be used to form tangible shapes that can be rearranged at will. From an algorithmic point of view, however, this self-reconfiguration process is a formidable challenge due to the kinematic, communication, control, and time constraints imposed on the modules during this process. We argue in this thesis that there exist ways to accelerate the self-reconfiguration of programmable matter systems, and that a new class of reconfiguration methods with increased speed and specifically tailored to tangible display systems must emerge. We contend that such methods can be achieved by proposing a novel way of representing programmable matter objects, and by using a dedicated reconfiguration platform supporting self-reconfiguration. Therefore, we propose a framework to apply this novel approach on quasi-spherical modules arranged in a face-centered cubic lattice, and present algorithms to implement self-reconfiguration in this context. We analyze these algorithms and evaluate them on classes of shapes with increasing complexity, to show that our method enables previously unattainable reconfiguration times.
... In the present paper, we develop the approach introduced in [16] much further into a more realistic framework. Arbitrary 3D structures are investigated, for which a linear-elastic FE model is again adopted, with the addition of unilateral contact conditions which represent interaction with the surroundings. ...
... Algorithmic prediction of two failure modes, shown in Fig. 1, will be analyzed, expanding on the ideas proposed in [16]. The first one is when addition of new blocks increases stresses at some inter-modular junctions beyond the holding capacity of connectors, as a result of which the structure breaks, Fig. 1a. ...
... Eq. (13) is solved iteratively using the weighted Jacobi scheme [16]. A single iteration i → i + 1 for module p reads: ...
Preprint
Full-text available
We present a distributed framework for predicting whether a planned reconfiguration step of a modular robot will mechanically overload the structure, causing it to break or lose stability under its own weight. The algorithm is designed to be executed by the modular robot itself and is based on an distributed iterative solution of mechanical equilibrium equations derived from a simplified model of the robot. The model treats inter-modular connections as beams and utilizes a no-sliding unilateral contact law between the modules and the ground. We also provide a simplified algorithm for detecting instability of a rigid robot on flat ground under gravitational loading. The algorithm is verified in simulations using the Programmable Matter simulator VisibleSim, and in real-life experiments using the modular robotic system Blinky Blocks.
... Some researchers have recently shown interest in this problem. In (Ho lobut and Lengiewicz, 2017), the authors mention two types of mechanical failures that can occur in a MSR: (1) loss of stability due to a shift in the center of mass of the system, which might be caused by the movement of modules; (2) structural failure, induced by the breaking of a bond between modules due to an excessive load imposed on a connector. The configuration stability problem was mentioned in , in which the authors state that stability can be insured under a few conditions, and for reconfiguration on a small class of shapes that they call stem cells, thanks to UCM traveling through the volume of the structure. ...
... The configuration stability problem was mentioned in , in which the authors state that stability can be insured under a few conditions, and for reconfiguration on a small class of shapes that they call stem cells, thanks to UCM traveling through the volume of the structure. Besides, failures due to overstressed connectors are investigated in (Ho lobut and Lengiewicz, 2017), where the authors present a distributed procedure for predicting if the next reconfiguration step will cause a structural failure. Ideally, procedures of this sort could be added to the planning process of self-reconfiguration algorithms so as to further constrain possible motions to mechanically safe ones exclusively. ...
Article
Full-text available
While researchers envision exciting applications for metamorphic systems like programmable matter, current solutions to the shape formation problem are still a long way from meeting their requirements. To dive deeper into this issue, we propose an extensive survey of the current state of the art of self/reconfiguration algorithms and underlying models in modular robotic and self-organizing particle systems. We identify three approaches for solving this problem and we compare the different solutions using a synoptic graphical representation. We then close this survey by confronting existing methods to our vision of programmable matter, and by discussing a number of future research directions that would bring us closer to making it a reality.
... This previous work did not consider the stability or robustness of the structures generated. Recent work in [11], [12] examined the forces between individual components and evaluated if a structure of module robots would be stableif it would topple or collapse under its own weight, especially during the process of reconfiguration. ...
Preprint
Full-text available
This paper examines a family of designs for magnetic cubes and counts how many configurations are possible for each design as a function of the number of modules. Magnetic modular cubes are cubes with magnets arranged on their faces. The magnets are positioned so that each face has either magnetic south or north pole outward. Moreover, we require that the net magnetic moment of the cube passes through the center of opposing faces. These magnetic arrangements enable coupling when cube faces with opposite polarity are brought in close proximity and enable moving the cubes by controlling the orientation of a global magnetic field. This paper investigates the 2D and 3D shapes that can be constructed by magnetic modular cubes, and describes all possible magnet arrangements that obey these rules. We select ten magnetic arrangements and assign a "colo"' to each of them for ease of visualization and reference. We provide a method to enumerate the number of unique polyominoes and polycubes that can be constructed from a given set of colored cubes. We use this method to enumerate all arrangements for up to 20 modules in 2D and 16 modules in 3D. We provide a motion planner for 2D assembly and through simulations compare which arrangements require fewer movements to generate and which arrangements are more common. Hardware demonstrations explore the self-assembly and disassembly of these modules in 2D and 3D.
... Besides, regarding the mechanical aspect of selfreconfiguration, we assume for now that all intermediate configurations are stable, as efficiently ensuring the mechanical stability of reconfiguration is an ongoing intractable problem (Hołobut and Lengiewicz, 2017). ...
Article
Full-text available
The self-reconfiguration of large swarms of modular robotic units from one object into another is an intricate problem whose critical parameter that must be optimized is the time required to perform a transformation. Various optimizations methods have been proposed to accelerate transformations, as well as techniques to engineer the shape itself, such as scaffolding which creates an internal object structure filled with holes for easing the motion of modules. In this paper, we propose a novel deterministic and distributed method for rapidly constructing the scaffold of an object from an organized reserve of modules placed underneath the reconfiguration scene. This innovative scaffold design is parameterizable and has a face-centered-cubic lattice structure made from our rotating-only micro-modules. Our method operates at two levels of planning, scheduling the construction of components of the scaffold to avoid deadlocks at one level, and handling the navigation of modules and their coordination to avoid collisions in the other. We provide an analysis of the method and perform simulations on shapes with an increasing level of intricacy to show that our method has a reconfiguration time complexity of $O(\sqrt[3]{N})$ time steps for a subclass of convex shapes, with $N$ the number of modules in the shape. We then proceed to explain how our solution can be further extended to any shape.
... Furthermore, an aspect of self-reconfiguration that should be further considered is the mechanical constraints imposed on the system. Two main types of mechanical failures are identified in [14]: (1) loss of stability due to a shift in the center of mass of the system; (2) structural failure, caused by the breaking of a bond between modules after an excessive stress. While Hołobut and Lengiewicz also present a distributed procedure for predicting if the next reconfiguration step will cause a structural failure in their paper, to the best of our knowledge, no self-reconfiguration algorithm truly considers mechanical constraints in their design-when these same constraints might prevent them from working in practice. ...
Conference Paper
Full-text available
In the context of large distributed modular robots, self-reconfigura-tion is the process of having modules, seen as autonomous agents, acting together and moving to transform the morphology of their physical arrangement to produce a desired shape. However, due to motion constraints, the number of modules that can move concurrently is greatly limited, thus making self-reconfiguration a very slow process. In this paper, we propose an approach for accelerating self-reconfi-guration to build a porous version of the desired shape, using scaffolding. We expand this idea and propose a method for constructing a parametric scaffolding model that 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 guarantees that module movements and the construction of the scaffold are deterministic. Coupled with an underneath reserve of modules that allows the introduction of rotating quasi-spherical modules at various ground locations of the growing porous structure, our method is able to build the scaffolding structure in O(N^2/3) time with N the number of modules composing the structure. Furthermore, we provide simulation results showing that our method uses O(N^4/3) messages with no congestion.
Conference Paper
This paper examines a family of designs for magnetic cubes and counts how many configurations are possible for each design as a function of the number of modules. Magnetic modular cubes are cubes with magnets arranged on their faces. The magnets are positioned so that each face has either magnetic south or north pole outward. Moreover, we require that the net magnetic moment of the cube passes through the center of opposing faces. These magnetic arrangements enable coupling when cube faces with opposite polarity are brought in close proximity and enable moving the cubes by controlling the orientation of a global magnetic field. This paper investigates the 2D and 3D shapes that can be constructed by magnetic modular cubes, and describes all possible magnet arrangements that obey these rules. We select ten magnetic arrangements and assign a "color" to each of them for ease of visualization and reference. We provide a method to enumerate the number of unique polyominoes and polycubes that can be constructed from a given set of colored cubes. We use this method to enumerate all arrangements for up to 20 modules in 2D and 16 modules in 3D. We provide a motion planner for 2D assembly and through simulations compare which arrangements require fewer movements to generate and which arrangements are more common. Hardware demonstrations explore the self-assembly and disassembly of these modules in 2D and 3D.
Article
In this paper, we present a reconfiguration algorithm for shape-shifting modular robots with a triangular structure. The algorithm is derived from a novel description of the configuration space based on extended binary trees. Extended binary trees representing the same configuration are grouped into equivalence classes, which allows for a one-to-one correspondence between a configuration and its mathematical representation. Reconfiguration is then accomplished by a successive construction of the goal configuration, realized by moving individual modules along the surface of the robot and building up the binary tree of the goal configuration by populating unoccupied binary tree indices in ascending order with new modules. The algorithm is capable of solving the self-reconfiguration problem for modular robots with a triangular structure in O(n2) reconfiguration steps and is demonstrated on two reconfiguration examples. We then discuss the limits of the proposed methods, regarding constraints on the implementation and the lack of efficient collision avoidance, and outline possible resolutions.
Conference Paper
Full-text available
Module localization is an important aspect of the operation of self-reconfigurable robots. The knowledge of spatial positions of modules, or at least of the overall shape which the modules form, is the usual prerequisite for reconfiguration planning. We present a general, decentralized algorithm for determining the positions of modules placed on a cubic grid from local sensor information. The connection topology of the robot is arbitrary. We assume that a module can sense the presence of its immediate neighbors on the grid and determine their positions in its own local coordinate system, but cannot sense the orientations of the coordinate systems of its neighbors. Since orientation cannot be directly communicated between modules, the modules can only exchange information about the relative positions of their neighbors. The algorithm aggregates this information over the entire network of modules and narrows down the set of valid positions for each module as far as possible. If there exists a unique locally-consistent assignment of coordinates to all modules then it is found.
Article
Full-text available
We propose a new class of modular-robotic structures, intended to produce forces which scale with the number of modules. We adopt the concept of a spherical catom and extend it by a new connection type which is relatively strong but static. We examine analytically and numerically the mechanical properties of two collective-actuator designs. The simulations are based on the discrete element method, with friction and elastic deformations taken into account. One of the actuators is shown to generate forces proportional to its volume. This property seems necessary for building modular structures of useful strength and dimensions.
Conference Paper
Full-text available
The term Programmable Matter (PM) describes the class of future meta-materials of programmable and controllable properties and behavior, e.g., able to autonomously transform into an arbitrary shape. The robotic approaches towards PM are based on the concept of cooperation of millions of micro-robots (modules), acting at a very fine length-scale and collectively imitating deformation of a macroscopically continuous material. Recent ideas about reconfiguration of a collective of modules to obtain a desired overall mechanical response are promising. However, they are limited by the strength of individual connections between modules. In the present work, we propose a way of arranging spherical modules into microstructures, in which some connections are fixed and mechanically stronger, and the rest are active (reconfigurable) but weaker. If the fixed connections are sufficiently strong, the proposed microstructures perform the function of collective actuation by exerting forces proportional to their volumes. Two variants of a linear-actuator microstructure are presented and studied in more detail. A rotary-actuator microstructure is also introduced.
Article
Full-text available
Abstract In this thesis we look at control in the context of self-reconfigurable robots. A self-reconfigurable robot is a robot built from potentially many modules which are connected to form the robot. Each module has sensors, actuators, processing power, and means of communicating with connected modules. The robot autonomously changes shape by changing the way these modules are connected. Self-reconfigurable robots have a high degree of robustness, versatility, scale extensibility, and adaptability. This makes these robotic systems interesting to study. We introduce role-based control, which is a method used to implement locomotion gaits in chain-type self-reconfigurable robots. Using this method we have implemented four dierent,locomotion gaits on the CONRO self- reconfigurable robot. Furthermore, we show how the robot can change be- tween these locomotion patterns when it is dynamically reconfigured. We show in a series of experiments that role-based control has the following characteristics. 1) The control is robust to communication errors and mod- ule failure. 2) The number of modules can be changed during run-time. 3) Sensor information can be incorporated into role-based control making it possible for the robot to adapt the locomotion gait to the environment. 4) The eciency,of the control after initial synchronization does not depend on the number of modules. 5) The control system is simple and minimal. 6) New locomotion patterns can be implemented relatively systematically using role-based control. We also introduce a method to control the self-reconfiguration process. This method consists of two components. The first component takes a CAD model of a desired shape and generates cellular automata rules which take the global aspect out of the self-reconfiguration problem. The second compo- nent takes these rules and combines them with artificial chemical gradients
Article
Full-text available
We survey general techniques and open problems in numerical linear algebra on parallel architectures. We first discuss basic principles of paralled processing, describing the costs of basic operations on parallel machines, including general principles for constructing efficient algorithms. We illustrate these principles using current architectures and software systems, and by showing how one would implement matrix multiplication. Then, we present direct and iterative algorithms for solving linear systems of equations, linear least squares problems, the symmetric eigenvalue problem, the nonsymmetric eigenvalue problem, and the singular value decomposition. We consider dense, band and sparse matrices.
Article
This article describes a 2D and 3D simulation engine that quantitatively models the statics, dynamics, and nonlinear deformation of heterogeneous soft bodies in a computationally efficient manner. There is a large body of work simulating compliant mechanisms. These normally assume small deformations with homogeneous material properties actuated with external forces. There is also a large body of research on physically based deformable objects for applications in computer graphics with the purpose of generating realistic appearances at the expense of accuracy. Here we present a simulation framework in which an object may be composed of any number of interspersed materials with varying properties (stiffness, density, Poisson's ratio, thermal expansion coefficient, and friction coefficients) to enable true heterogeneous multimaterial simulation. Collisions are handled to prevent self-penetration due to large deformation, which also allows multiple bodies to interact. A volumetric actuation method is implemented to impart motion to the structures, which opens the door to the design of novel structures, and mechanisms. The simulator was implemented efficiently such that objects with thousands of degrees of freedom can be simulated at suitable frame rates for user interaction with a single thread of a typical desktop computer. The code is written in platform agnostic C++ and is fully open source. This research opens the door to the dynamic simulation of freeform 3D multimaterial mechanisms and objects in a manner suitable for design automation.
Article
Previous work on self-reconfiguring modular robots has concentrated primarily on designing hardware and developing reconfiguration algorithms tied to specific hardware systems. In this paper, we introduce a generic model for lattice-based self-reconfigurable robots and present several generic locomotion algorithms that use this model. The algorithms presented here are inspired by cellular automata, using geometric rules to control module actions. The actuation model used is a general one, assuming only that modules can generally move over the surface of a group of modules. These algorithms can then be instantiated onto a variety of particular systems. Correctness proofs of many of the rule sets are also given for the generic geometry; this analysis can carry over to the instantiated algorithms to provide different systems with correct locomotion algorithms. We also present techniques for automated analysis that can be used for algorithms that are too complex to be easily analyzed by hand.
Article
We present the automated design and manufacture of static and locomotion objects in which functionality is obtained purely by the unconstrained 3-D distribution of materials. Recent advances in multimaterial fabrication techniques enable continuous shapes to be fabricated with unprecedented fidelity unhindered by spatial constraints and homogeneous materials. We address the challenges of exploitation of the freedom of this vast new design space using evolutionary algorithms. We first show a set of cantilever beams automatically designed to deflect in arbitrary static profiles using hard and soft materials. These beams were automatically fabricated, and their physical performance was confirmed within 0.5–7.6% accuracy. We then demonstrate the automatic design of freeform soft robots for forward locomotion using soft volumetrically expanding actuator materials. One robot was fabricated automatically and assembled, and its performance was confirmed with 15% error. We suggest that this approach to design automation opens the door to leveraging the full potential of the freeform multimaterial design space to generate novel mechanisms and deformable robots.
Article
This paper presents an overview of parallel algorithms and their implementations for solving large sparse linear systems which arise in scientific and engineering applications. Preconditioners constitute the most important ingredient in solving such systems. As will be seen, the most common preconditioners used for sparse linear systems adapt domain decomposition concepts to the more general framework of “distributed sparse linear systems”. Variants of Schwarz procedures and Schur complement techniques are discussed. We also report on our own experience in the parallel implementation of a fairly complex simulation of solid-liquid flows.
Article
This paper is a manifesto, a brief tutorial, and a call for experiments on programmable matter machines.