Content uploaded by Jakub Lengiewicz

Author content

All content in this area was uploaded by Jakub Lengiewicz on May 18, 2021

Content may be subject to copyright.

Distributed computation of forces in modular-robotic ensembles as part

of reconﬁguration planning*

Paweł Hołobut and Jakub Lengiewicz

Abstract— We discuss selected mechanical aspects of self-

reconﬁguration 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, reconﬁguration

affects the forces between modules. We present a distributed

procedure by which a robot can predict if the next planned

reconﬁguration 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 efﬁciency.

I. INTRODUCTION

Self-reconﬁgurable 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 ﬁll 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 “ﬂowing” 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 reconﬁguration

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

reconﬁguration, it is expected that the modules do not overlap

and that the robot remains connected, and also that individ-

ual modules obey certain procedure-speciﬁc 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

reconﬁguration 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 conﬁguration of the robot. Thereby it can be

decided in advance if a planned reconﬁguration 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 simpliﬁed methodology for assessing the

compliance of ﬁxed-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

reconﬁguration one step ahead. It follows the ideas of [3]

and [17], and is a synthesis of three components. The

ﬁrst one is the method of simpliﬁed 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

reconﬁguration 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-reconﬁguration 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

ﬁgures, 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. Reconﬁguration steps

Reconﬁguration of modular robots can be approximately

considered a discrete process. Assuming fast creation/release

of connections, the change of connection topology of a ﬁnite

robot proceeds in steps, as is illustrated in Fig. 1. The ﬁrst

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 reconﬁguration.

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 reconﬁguration

There are two types of mechanical failure, shown in

Fig. 2, which should be addressed when doing an analysis

of reconﬁguration. The ﬁrst 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 reconﬁguration (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 reconﬁguration (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-

conﬁguration (phase c–d in Fig. 1) is not potentially dam-

aging, as it can only increase the stiffness and strength of a

structure.

The ﬁrst 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 reconﬁguration step is actually made, is

discussed in the rest of the paper. The problem we consider

is a problem of veriﬁcation, which may also be made a part

of planning, and can be stated as follows:

The system reconﬁgures following a plan designed by an

independent procedure. The next planned step of reconﬁgu-

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 reconﬁguration 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 reconﬁguration: (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 ﬁrst 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

0−12I6IL

0−6IL 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 conﬁguration.

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 conﬁgu-

rations: unloaded Ω, loaded ω, and perturbed ¯ω; see Fig. 3.

The loaded conﬁguration represents the actual state of the

modular system and the perturbed conﬁguration 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 ﬁrst

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#=¯

Fp−X

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 conﬁguration.

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 reconﬁguration 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

classiﬁed 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

p−X

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 coefﬁcient 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 satisﬁed, one may expect the

junction to hold. Otherwise it may fail. For different types

of junctions and different module geometries, other case-

speciﬁc 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 veriﬁed 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 speciﬁc 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 ﬁxed, cf. Fig. 4.

Similarly, in Problem 2, the robot forms a shape with holes

with its top layer of modules ﬁxed, cf. Fig. 5. Both robots

are loaded by their own masses in the gravitational ﬁeld

(assumed mass of a single module m= 4 ×10−6[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 signiﬁcant

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

signiﬁcant tensile forces. It was not the case for Problem 2,

for which the axial and shear loads in the non-perturbed

conﬁguration are relatively low and it would be difﬁcult 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 magniﬁed by the lever that was formed after the

reconﬁguration.

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 conﬁgurations 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 modiﬁed (blue)

conﬁgurations. Deformation ampliﬁed 5×for better visibility.

Fig. 5. Problem 2. Unloaded (gray), loaded (red), and modiﬁed (blue)

conﬁgurations.

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

(ﬁve 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 reconﬁguration planning. Still, we believe it is

the ﬁrst 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-

ﬁguration step, but is otherwise unconstructive. It would be

Fig. 6. Problem 1. Axial forces for the deformed physical conﬁguration (left) and predicted axial forces for the modiﬁed conﬁguration (right). Deformation

ampliﬁed 5×for better visibility.

Fig. 7. Problem 1. Shear forces for the deformed physical conﬁguration (left) and predicted shear forces for the modiﬁed conﬁguration (right). Deformation

ampliﬁed 5×for better visibility.

Fig. 8. Problem 2. Axial forces for the deformed physical conﬁguration (left) and predicted axial forces for the modiﬁed conﬁguration (right).

desirable to adapt it for longer-range prediction, or utilize

the short-range results for optimizing reconﬁguration.

Secondly, the Jacobi-type iterative procedure is inefﬁcient.

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 efﬁcient. However, it may also turn out that real

efﬁciency 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 insufﬁcient 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-reconﬁgurable 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 conﬁguration (left) and predicted shear forces for the modiﬁed conﬁguration (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-reconﬁgurable 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-reconﬁgurable 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-reconﬁguring 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-reconﬁgurable 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-

reconﬁguration,” 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 ﬁnite element method: linear static and dynamic

ﬁnite 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 ﬁnite 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.