Self Assembly of Modular Manipulators with Active and

Self Assembly of Modular Manipulators

with Active and Passive Modules

Seung-kook Yun and Daniela Rus

Computer Science and Artificial Intelligence Laboratory

Massachusetts Institute of Technology, Cambridge, Massachusetts, USA

[email protected],[email protected]

Abstract— We describe self-assembling robot arm systemscomposed of active modular robots and passive bars. We presenta case study where the robotic module is the Shady3D robotand the passive component is a rigid bar with embedded IRLEDs. We propose algorithms that demonstrate the cooperativeaggregation of modular robotic manipulators with greatercapability and workspace out of these two types of elements. Wepresent results from physical experiments in which two 3DOFShady3D robots and one rigid bar coordinate to self-assembleinto a 6DOF manipulator. We then demonstrate cooperativealgorithms for forward and inverse kinematics, grasping, andmobility with this arm.

I. INTRODUCTION

This paper explores the development of low-cost modular

manipulators. Drawing from the theoretical, practical, and

existing experience in manipulation and modular robotics,

we propose an approach to synthesize modular manipulators

that match a desired workspace by self-assembly. We en-

vision robot systems capable of scavenging raw materials

from the environment to adaptively create dynamic pro-

grammable structures that integrate robotic elements with

passive components. We describe how a collection of simple

robotic modules can grasp rigid bars and coordinate to

self-assembled robotic manipulators with a higher number

of degrees of freedom and a larger workspace than the

components. The resulting robot arms are distributed mobile

manipulation systems that can be controlled to accomplish

the basic functionality of a robot arm: inverse kinematics,

forward kinematics, grasping, and pick and place. These

arms can move autonomously to different places in the

workspace. The specific type of arm we study alternates

robotic elements with rigid bars. The presence of the rigid

bars enhances the structural rigidity of the system and also

contributes to the total number of degrees of freedom of the

system. The total number of elements is determined by the

required workspace size. We aim to synthesize the smallest

robot structure that meets the workspace requirements.

The challenge in building self-assembled modular arms

ranges from issues related to designing simple and robust

active modules capable of interacting with other passive and

active modules, to problems of control and planning. Control

is challenging because each active link is a separate robot.

The many degrees of freedom of these systems have to be

coordinated using distributed and efficient controllers.

We present algorithms for the self-assembly of multi-link

robot arms out of 3DOF robot modules with the structure

and capabilities of our robot Shady3d [1] and rigid bars

with embedded LEDs for guiding grasping. We assume to

know the location of the robot modules and of a cache of

smart passive bars. Given a desired workspace, we determine

the number of needed links. A distributed self-assembly

algorithm constructs the robot arm as an alternation of robot

elements and passive bars. We demonstrate this algorithm

in the context of creating a 6DOF manipulator out of two

Shady3D elements and one passive bar. We also present

cooperative algorithms for forward and inverse kinematics,

grasping, and pick and place and give data from physical

experiments.

A. Related work

We build on prior work on modular manipulators [2] and

self-reconfiguring robots [2]–[7]. Previous work on modular

manipulators considers how to manually assemble an arm,

given a collection of modules. Most previous work on self-

reconfiguring robots considers a homogeneous system that

has multiple copies of the same part. In our project we

depart from the premise of homogeneous robots and describe

heterogeneous modular robots with active and passive links.

The robot arms we propose are closely related to truss

climbing robots such as Staritz et al’s “Skyworker” [8],

Amano et al’s handrail-gripping robot for firefighting [9],

Ripin et al’s pole climbing robot [10], Nechba, Xu, Brown

et al’s “mobile space manipulator SM2” [11], Kotay and

Rus’ “Inchworm” [12], and Almonacid et al’s parallel mech-

anism for climbing on pipe-like structures [13] and our own

Shady2D and Shady3D modules [14].

B. Outline

This paper is organized as follows. Section II reviews the

capabilities of Shady3D, the robot module we use in this

work. Section III presents the self-assembly algorithm and

experimental results for the self-assembly to a 6DOF arm.

We propose control algorithms for the inverse kinematics

control of serial linkages in Section IV. Section V describes

the algorithms and the results of physical experiments for

kinematics, inverse kinematics, grasping, and pick and place

with the 6DOF arm.

2008 IEEE International Conference onRobotics and AutomationPasadena, CA, USA, May 19-23, 2008

978-1-4244-1647-9/08/$25.00 ©2008 IEEE. 1477

Authorized licensed use limited to: MIT Libraries. Downloaded on June 5, 2009 at 23:17 from IEEE Xplore. Restrictions apply.

1478


A. Self-assembly algorithms

The output of the workspace computation algorithm is

a linkage manipulator which consists of serially connected

n robots and (n − 1) passive links and meets the task

requirement.

We want n robots to come together on the support structure

necessary to anchor the arm and them to build the linkage

together. The cooperation among the robots relies only on

local communication with a limited range.

More specifically, we assume:

• The support environment and location of the robots is

given in the form of a graph with nodes and edges as

described in [17].

• The target location is reachable from every robot’s

starting point.

• A robot has a unique ID.

• Robots can communicate only when they are nearby:

located on adjacent nodes.

• using communication, a robot can read the state of the

other robot and send a control command.

• Locations of the passive bars are given.

The coordination of the robots is done using a state

variable. robots use the state to indicate to other robots what

they are doing. We use the following states:

• Idle: waiting for a command

• Moving: motors are working

• Assembling: doing self-assembly now

• Assembled: assembled with other robots

Algorithm 1 Building serially linked robots

1: Locomote to the anchor point (Algorithm 2)

2: if anchor is empty then

3: Be the root of the linkages

4: else

5: while The root robot’s state6=Assembled do

6: Delay

7: end while

8: Add myself to the linkages (Algorithm 3)

9: end if

Algorithm 1 gives the high-level planning algorithm. Once

robots are initialized, they independently travel to the loca-

tion of the arm with Algorithm 2. Firstly, each robot finds the

best route to the anchor point by Dijkstra’s algorithm. Every

time they advance to the next node, they check whether that

node is already occupied. If not, they move. Otherwise, they

wait until the node is empty. Since the anchor is the same

for all the robots, there is no deadlock. Details of distributed

deployment for the general case was extensively reviewed

in [17].

The first robot to arrive at the anchor location becomes the

root. The root robot communicates to the robots approaching

the anchor. The robots are assembled into the linkages in

order of their arrival at the anchor point using Algorithm 3.

Note that Algorithm 3 can be used for the root robot of the

arm.

Algorithm 2 Locomotion to the anchor point

1: Find the shortest path to the anchor

2: while not reached the target or not met the linkages do

3: Communicate with adjacent robots

4: if next node is empty then

5: Move to the next node

6: else

7: Wait until the next node is empty

8: end if

9: end while

The addition of new modules starts from moving the

robot to the nearest approachable node. The robot then

communicates with the root robot of the arm, in order to let

it grasp the other side of the bar and assemble it. The robot

uses information about the location of the passive bar and

grasps it, guided by the emitter on the bar’s grasping point.

To reach the grasping point, the robot and the arm uses the

inverse kinematics algorithm described in Section IV.

Algorithm 3 Addition of a robot to serial linkages by Self-

assembly

1: State = Moving

2: Move to the nearer approachable node

3: State = Idle

4: while the other approachable node is empty do

5: Communicate with the adjacent robot

6: end while

7: Let the root robot assemble me

8: State = Assembling

9: Move to check the passive bar

10: if sense a bar then

11: Grasp the bar

12: State = Idle

13: while The root robot’s State6=Assembled do

14: Delay

15: end while

16: State = Assembled

17: else

18: Return to the original position

19: State = Idle

20: end if

After self-assembly to new serial linkages, we assign two

roles to the first and the last robot: a root and a leaf, where

the former has a fixed gripper at the truss while the latter

is the end point of the linkages. The fixed gripper of a root

is called an anchor and the free gripper of a leaf is an end-

effector.

B. Experiments with self-assembly of two Shady3Ds

The proposed algorithms are implemented in experiments

with two Shady3D robots and one bar. Figure 6 shows

snapshots from the experiment. Firstly, given a specified

position for the passive bar within the Shady3D experimen-

tal environment, each Shady3D module optimally positions

1479


itself so as to be able to reach the bar. Details of the optimal

deploying algorithm are addressed in [17]. In the first step

of the algorithm each Shady3D module moves independently

and in parallel to reach and grasp the bar. The bar is detected

using the LED sensors within the Shady3D grippers. Upon

grasping the bar, the Shady3D modules signal to each other

using Bluetooth to coordinate the completion of the grasping

step and the self-assembly of a 6DOF manipulator. We tested

the self-assembly, and a sequence of 10 executions resulted

in no error. Each self-assembly experiment took 1 minute

(See Table I).

IV. CONTROLLING THE MODULAR ARM BY DISTRIBUTED

INVERSE KINEMATICS

Reaching an arbitrary point in space by serial linkages

requires robot coordination. Unfortunately, the structure of

Shady3D does not allow a closed-form inverse kinematics

solution even for the simplest 6DOF linkages from two

robots. Instead of using an explicit solution, we use an

approximation algorithm based on the manipulator jacobian.

We select a Damped Least Square (DLS) method because it

has good robustness and performance [18].

Only the root robot calculates the joint angles to grasp

a bar when needed. The solution propagates along the

linkages by successive communication to the leaf robot.

When sending the angles, each robot cut off the first three

angles from the solution and send the remaining ones. Then

it rotates by those three angles. After finishing moving, the

robot await that the leaf-side robot stop rotating, by checking

its status. Therefore, the status of the robots change in one

by one from the leaf to the root.

V. MANIPULATION TASKS WITH MODULAR 6DOF ARM

We have developed algorithms for four kinds of tasks

with the manipulator. The algorithms were implemented on

our physical prototype 6DOF modular manipulator. In each

case, task information is given to the robots in the form of a

command stack. The robots decide which role to play based

on the task specification and its location.

A. Distributed control algorithm for task execution

Each task is a stack of command sets for the two robots,

and how a robot execute the task is shown in Algorithm 4.

Parameters of the command set are:

• RootNode (#): the root location to anchor the arm

• Displacement (x,y,z,roll,pitch,yaw / θ1 · · ·θ6): 6 joint

movements and end-effector displacement

• Grasp (G/R): grasp/release of the end-effector

Each robot starts by finding out if it is a root. The root

robot calculates the joint displacement of two robots directly

or indirectly by inverse kinematics. The leaf robot waits

for a command. The root sends the corresponding joint

displacements to the leaf robot. Then they both execute their

next command in parallel. The root checks the command

completion, and then pops the next command set until the

stack is empty.

Algorithm 4 Task execution

1: while Task Stack not empty do

2: Pop the next queue

3: if Anchor = Root then

4: Get the commands from the queue

5: Send the command for the leaf

6: State = Moving

7: Execute my command

8: while The leaf’s State = Moving do

9: Delay

10: end while


12: else

13: Wait for the command from the root

14: State = Moving

15: Execute my command


17: end if

18: end while

B. XYZ-directional movement

In this task, the distributed inverse kinematics protocol is

used to implement the positioning of the arm’s end effector

at a desired location (x,y,z). The arm’s initial configuration

is shown in Figure 7(a). The left gripper of the arm is the an-

chor and the right gripper is the end-effector. We have tested

different (x,y,z) locations for the 6DOF manipulator built

in Section V as shown in Figure 7(b-c). Each experiment

was done 10 times without error and it took 20 seconds(See

Table I.) In this case, the task stack has only one command

set with a single end-effector displacement.

One challenge is coping with the position error along

the vertical axis - in this case, Z-directional - because of

tilting of the arm due to gravity. About 20mm error was

measured regardless of the Z-directional displacement. The

error mainly comes from mechanical weakness of a robot

(e.g. backlash, tolerances, and plastic material).

C. Reaching nodes unreachable by one robot

Consider an inspection task which requires reaching every

point on the truss. As pointed out in [16], some points on

the truss are unreachable by one robot due to its fixed length

and 3DOF. When we model the truss environment as a graph

where nodes are points of interest and edges correspond to

reachability among the nodes, such unreachable points are

nodes without an edge. Upon self-assembly, many unreach-

able points become reachable by the 6DOF linkage because

of enhanced workspace and additional DOFs.

Figure 8 shows the self-assembled robot built in Section V.

reaching the unreachable nodes(denoted by the arrows). The

task stack has one command set with a single end effector

displacement according to 3-D locations of the nodes. Three

unreachable nodes were tested ten times each without error.

Each task took 40 seconds(See Table I.) The position error

along the vertical axis due to the mechanical weakness of the

arm persists for the task as well with an observed maximum

1480


(a) (b) (c)

Fig. 6. Implementation of self-assembly of 6DOF modular arm and an example of moving a bar. (a) Two robots have moved to the approachable nodes.(b) They are swinging their body to find the bar. (c) They have grasped each side of the bar.

(a) (b)

(c) (d)

Fig. 7. Uni-directional movement of a 6DOF manipulator composedof self-assembled Shady3Ds. (a) A self-assembled manipulator with twoShady3Ds. The left gripper is anchored at the truss and the right oneis free to move. (b) X-directional movement with 150mm displacement(c) Y-directional movement with 150mm displacement (d) Z-directionalmovement with 150mm displacement

(a) (b)

Fig. 8. A 6DOF manipulator with two Shady3Ds reaches some nodeswhich are unreachable by one robot. The robot can be anchored anywherein the environment.

60mm tilting. In our environment, the self assembled 6DOF

can reach all the nodes.

D. Pick and drop by forward kinematic control

In this task, the arm collects an object(a bar), moves to a

different location where it drops the object. This task requires

a 6DOF manipulator. The locations of pick and drop are

given by joint angles. The robot moves by distributed forward

kinematic control.

The task stack is composed of 7 command sets each of

which has one joint displacement or grasping/release. As

the task starts, one of the modules releases its grasp of the

environment. Figures 9(a, b, c) shows two modules controlled

independently and in parallel to demonstrate the movement

of the arm. An additional bar is manually presented to the

free gripper of the 6DOF manipulator. The bar is grasped,

transported, and dropped at a specified location (see Figure 9

(d, e, f).) We have performed this experiment 10 times in a

row during the course of one hour. Each experiment consisted

of 9 joint movements and 5 grasping/release operations, and

it took about 140 seconds. All the control steps succeeded

for all the experiments. However, due to a hardware failure

at the end of the 7th experiment one of the gripper motors

had to be replaced(See Table I.)

A summary of our experiments is shown in Table I.

VI. CONCLUSIONS AND FUTURE WORKS

In this paper we discussed our first step toward building a

self-assembled robot composed of passive components and

modular manipulators. As a first stage, we designed a module

with the minimal number of joints for 3D movement and

building a 6DOF manipulator. By combining two modules

and one passive bar, we can generate a more capable robot.

We described a suite of algorithms and experiments for

building a serial linkage. We proposed the inverse kinematics

to control multi-robot in 3D space without serous position

error and long convergence time. Hardware implementation

of building a 6DOF manipulator and several tasks show

how the proposed self-assembly works in the real world.

The coordinated manipulation algorithms perform well. They

are generally robust and the response time is adequate for

the tasks we considered. However, the materials used in the

prototype cause a structured tilting error which has to be

eliminated in future versions.

Much work remains to be done in the direction of building

modular robots with active and passive components. There

is a great need for a better hardware design and high-level

distributed planning algorithms.

VII. ACKNOWLEDGMENTS

This work was supported in part by NSF IIS-0426838,

NSF EFRI-0735953 and NSF CNS-0707601. Seung-kook

1481


1482


Documents

Self Assembly of Modular Manipulators with Active and