Authors : Arancha Casal , Mark Yim
Xerox Palo Alto Research Center
Robotics Laboratory, Stanford University

ABSTRACT

Modular self-reconfigurable Robots consist of large numbers (hundreds or thousands) of identical modules that possess theability to reconfigure into different shapes as required by the task at hand. For example, such a Robot could start out as asnake to traverse a narrow pipe, then re-assemble itself into a six-legged spider to move over uneven terrain, growing a pairof arms to pick up and manipulate an object at the same time.

This paper examines the self-reconfiguration problem and presents a divide-and-conquer strategy to solve reconfiguration fora class of problems referred to as closed-chain reconfiguration. This class includes reconfigurable robots whose topologiesare described by one-dimensional combinatorial topology. A robot topology is first decomposed into a hierarchy of small“substructures” (subgraphs of modules) belonging to a finite set. Basic reconfiguration operations between the substructuresin the set are precomputed, optimized and stored in a lookup table. The entire reconfiguration then consists of an orderedseries of simple, precomputed sub-reconfigurations happening locally among the substructures.

1. INTRODUCTION

Modular self-reconfigurable robotics is a relatively new concept that is gaining in popularity as evidenced by the increasingnumber of research groups building and studying these systems [1-11]. The basic idea is that a complex Robotic system canbe constructed from a collection of many simple, self-contained elements or modules, whose functionality comes from themodules interacting together and being able to self-assemble in different ways.

The ability to change shape as needed translates into high task versatility. Potential applications fall within three broadcategories: locomotion, manipulation, and static structures. The large range of possible shapes allow these systems toaccomplish tasks in all three categories. A scenario that may require all three is during a search-and-rescue mission. A robotshape could be generated to traverse the narrow passages in a rubble pile and carry a camera to detect a potential victim.Another shape used to remove pieces of rubble, deliver communication and supplies. Finally a supporting structure can becreated to protect the victim.

This paper uses the term modular self-reconfigurable robot to refer to a system with the following characteristics:

• It is comprised of basic units called modules, where the modules are all identical. This allows for homogenous treatmentof the modules in the planning problem.
• A module can attach and detach from other modules and possibly have internal degrees of freedom.
• It can change its shape autonomously, by changing the connectivity among the modules.

A number of hardware designs exist which satisfy all of the above properties [1-10]. From the standpoint of reconfiguration,different implementations of the concept have resulted in three distinct “reconfiguration classes” differentiated by the modulemotion constraints and basic reconfiguration steps. These are presented in Section 2.Despite the relative hardware simplicity of the modules (as compared to other traditional robots), there are challengingresearch issues associated with the cooperative, distributed nature inherent to these systems. Self-reconfiguration, the focus ofthis paper, is one such issue.

The self-reconfiguration planning problem can be defined as the determination of a realizable sequence of module motionsthat changes an initial configuration into a desired goal configuration, without external intervention. When we considersystems with large numbers of modules, one of the main difficulties of self-reconfiguration resides in the fact that theattainable configurations can be extremely complex. A planner must compute a sequence of module motions to transformfrom an arbitrary initial configuration into the desired goal, both of which are possibly very intricate. A good planner must doso efficiently.

1.1 Optimal Reconfiguration
It would be desirable to design an optimal algorithm that minimizes the number of steps required to reach the finalconfiguration, or some other measure of optimality (total actuator effort, time, etc).

However, there is no simple solution for computing the optimal sequence of moves required to reconfigure. The reason is thatthe search space (that is, the number of possible sequences of configurations) grows exponentially with the number ofmodules in the system. As a result, we must look for heuristic solutions with some guarantee of performance.

The optimal reconfiguration problem was first studied by Pamecha et al. [18, 21]. It is a combinatorial optimization problemthat bears the hallmarks of a NP-complete problem, although no formal proof has been published yet. It is reminiscent of theclassical Transformation problem in Operations Research, which is NP-complete. But in the latter problem an externaloperator is allowed to move the pieces to goal locations in the target shape without any motion constraints [19,20].

1.2 Related Research
To this date, few algorithms to solve reconfiguration planning have been published. Owing to the computationally complexnature of the problem, the proposed solutions are non-optimal and work for restricted cases. They are discussed below.Pamecha et al. [21] present a near-optimal solution based on the minimization by simulated annealing of a formal"configuration distance" metric to measure the difference between an initial and a goal configuration. The method is onlycomputationally feasible for one module moving at a time. For typical systems consisting of large numbers of modules, therestriction of single module motion may render this solution too slow.

Yim et al. [2] introduce a rule-based heuristic method for a three dimensional system that centers around the setting ofordering and priorities and relies on cooperation to achieve individual module goals. Results are shown for large systemsinvolving multiple module motion, although pathological cases exist where complete reconfiguration is not achieved.Murata et al. [4,5] present a "stochastic relaxation" method implemented on two and three dimensional systems. The methodis based on potential fields and weighted probabilities to uniformly guide the motion of modules toward reachable positionsin the target configuration. A way to describe target shapes is also introduced and used in the algorithm. However, results arenot shown for large systems or arbitrary shapes.

All of the above algorithms were proposed for a class of reconfigurable systems in which modules nominally lie in discretepositions in a lattice. These kinds of systems have special characteristics, which determine which reconfiguration algorithmsare suitable to consider and are referred to as the substrate reconfiguration class. To the authors’ knowledge, this paper is thefirst time an approach has been published for the closed-chain reconfiguration class, and it can be subsequently used as astudy of the characteristics inherent to this class of problems. These classes are more fully described in Section 2.

The ideas of modularity and reconfigurability in robotics have appeared in the literature for other related concepts. Theseinclude versatile manipulator design based on the assembly of different specialized modules which can be (manually)combined in different ways to suit various tasks [12,13,14,15]; and cooperative systems of heterogenous mobile robots whichcan attach together in varying degrees and separate to achieve a common goal [16].

2. RECONFIGURATION CLASSES

The term “configuration” is used in the paper to refer to a distinct topology of the system, that is, a particular connectivityarrangement of the connected modules1.

We define the “reconfiguration space” to be the space of all configurations for a given set of labeled modules[28]. Twoconfigurations are adjacent if one can be transformed into the other by one atomic set of actions which we call an rmove. Theactions that define an rmove depend on the basic mobility of a module in a given set, typically consisting of one attach ordetach and some motion of the modules’ degrees of freedom. This mobility is used to differentiate modular selfreconfigurablesystems into one of three “reconfiguration classes”.

The three reconfiguration classes are: 1) Mobile Reconfiguration, 2) Substrate Reconfiguration and 3) Closed-chainReconfiguration. The reconfiguration class impacts the kinds of algorithms that are suitable to consider.

2.1 Mobile Reconfiguration
Mobile reconfiguration consists of modules that can move in an environment without the assistance of other modules. Thesetypically consist of a set of mobile bases that are individually maneuverable and that can also attach together. When modulesdisconnect and maneuver around the environment, the modules are no longer one single connected component. Since thereconfiguration space considers only the connected modules of the original set, we do not consider such instances to beconfigurations. We do not address the arrangements of multiple disconnected robots. The sequence of actions in an rmove ischaracterized by 1) a set of modules detach, 2) that set of modules maneuver in the environment, and 3) the set attaches tonew location(s). Examples of existing hardware systems include [11,16].

2.2 Substrate Reconfiguration
The class we refer to as Substrate reconfiguration includes systems where modules can only stop and attach to other modulesin discrete locations on a lattice. Motions between those locations occur only along prescribed paths. When a module istransitioning between two lattice positions, we do not consider such instances as configurations in the reconfiguration space.The sequence of actions in an rmove for substrate reconfigurations is typically 1) a set of modules detaches, 2) they move tonew location in the lattice, and 3) they attach to these new locations. Figure 1 is an illustration of a reconfiguration sequencefor a hardware system, Proteo, developed at Xerox PARC [2]. Several other hardware platforms in this class exist to date[4,5,6,7,10].

2.3 Closed-chain Reconfiguration
By contrast, Closed-chain reconfiguration relates to robot systems made up of serial kinematic chains (open or closed) whichcan meet at common branch-out points to form complex configurations. In this class, the basic reconfiguration primitiveinvolves a serial chain of modules reattaching its free end to a new point and possibly detaching from a different point. In theprevious two classes, an rmove consisted of both attach and detach actions and intermediate steps were not considered to be aconfiguration in the reconfiguration space. In this class, however, intermediate steps between attach and detach actions areindeed considered to be configurations in reconfiguration space. Thus an rmove for this class is either a single attach ordetach together with possibly some motion of the modules’ degrees of freedom. Figure 2 shows a reconfiguration sequencefor this class. Hardware implementations of this concept include Polypod[1] and its successor PolyBot[8], and CONRO[9].

2.4 Characteristics
Mathematically, the space of possible configurations for the closed-chain class is formalized by a one-dimensionalcombinatorial topology [17], where topological complexes, graphs in this case, are constructed from the combination of twobasic elements, or simplexes, namely edges and vertices. Surfaces, 3-D solids and polyhedra are excluded from this class,although skeletal framework approximations are possible.

Substrate systems have a more general topological space than the closed-chain type, and are particularly well suited to createsurfaces. Furthermore, if the modules in a substrate-type system can deform, it could have the same basic reconfigurationmechanics as a closed-chain system, albeit perhaps not to an advantage. Closed-chain type systems, however, still offerimportant advantages. Their mechanical implementation is, in general, simpler than for substrate-type systems. For manypractical locomotion and manipulation tasks, one-dimensional topological complexes suffice, and are in fact sometimespreferred. The algorithms presented in this paper apply to the closed-chain reconfiguration class. Nonetheless, the topologicalspace of this class can be a subset of the substrate class, and so the method could be used selectively on the latter.

Since the motion trajectories involved in an rmove for the substrate class consist of prescribed discrete motions over a latticethe related inverse kinematics and motion planning problems are greatly simplified. On the other hand, closed-chain systemswill, in general, require the generation of motion trajectories for chains made up of many modules. In these cases, thedimensionality of the related motion planning and kinematic considerations may be high. Optimal reconfiguration, asdiscussed in Section 1.1, is computationally intractable for both classes.

3. ALGORITHMS FOR CLOSED-CHAIN RECONFIGURATION

The method presented in this paper produces a sequence of connectivity changes for reconfiguration disregarding any motionplanning concerns. These considerations will be the subject of future work. The topological space covered by the method isthat of planar graphs (a subset of 1-dimensional combinatorial topology, see Section 3.3).

3.2 Equivalence between Configurations
The underlying module-to-module connectivity in a given configuration can be represented as a “module graph”, wherevertices correspond to individual modules and an edge is drawn between two modules if they are connected neighbors. Figure3 shows a robot configuration and its corresponding module graph. Note that from now on robot configurations will dedepicted by their wireframe equivalent, as introduced in this figure.

We define two configurations as equivalent iff their module graphs are the same. In the reconfiguration process, we can usethis definition of equivalence to determine if the goal configuration has been reached by the sequence of rmoves output by analgorithm.

3.3 Approach
The method proposed in this paper is a reductionist approach whereby a configuration is decomposed into a hierarchy ofsmall components, called substructures, which belong to a finite set. There are a number of operations defined on the setwhere, like an algebra, elements of the set can be combined to form another element in the set. Operations consist of simplereconfiguration sequences among substructures that are precomputed, optimized and stored in a lookup table for later use bythe planner. Modular reconfigurable robots are inherently distributed systems. This divide-and-conquer approach easilylends itself to a distributed implementation.

The initial and goal configurations, I and G respectively, are decomposed as an ordered hierarchy of components(substructures). The reconfiguration process consists of performing a correct sequence of operations among the substructuresof I to transform them into those of G and their corresponding hierarchical arrangement.

We refer to this approach as Hierarchical Substructure Decomposition (HSD). The proposed algorithms consist of two mainstages:

1. decomposition of I and G
2. reconfiguration using basic substructure operations

The remainder of this section will introduce the set of substructures and operations, and the hierarchy construction. It willalso discuss some of the characteristics inherent in the method, such as the non-uniqueness of decomposition, and theirconsequences. It will then present two similar HSD-based algorithms for reconfiguration.

3.3.1 Substructure Set
A set of substructures s is selected as the basic elements with which to construct complexes (configurations). Thesesubstructures are topological groupings of several modules that satisfy the following characteristics:

1. They are topologically distinct or non-homeomorphic, i.e. one cannot change into the other without changing itsconnectivity.
2. They appear recurringly in a large number of configurations.
3. The reconfiguration operations between any two in the set are simple and well-known.

• A chain is a continuously connected series of modules.
• A loop is a chain whose two ends are connected or a cycle of chains.

A number of basic reconfiguration operations are defined for s. These operations are:

• transformation into a different substructure in the set
• merge of two connected substructures
• split of a substructure in two
• relocation of a substructure with respect to its parent substructure

The first three operations all involve a small number of rmoves. The relocation operation also involves a small number ofrmoves. Nevertheless, when we consider a real motion trajectory to realize the relocation, it may be the case that the numberof rmoves needs to be large. For example, consider a substructure with short reachability that must nonetheless reach a targetlocation a long distance away. In reality, several rmoves may be needed to complete the relocation operation, each of whichmove it increasingly closer to the target location. This paper, however, does not address the issue of reachability and motionplanning for trajectories (see Section 2.4); thus relocation operations are indeed trivial.

3.3.2 Hierarchy Construction
The decomposition step first involves traversing the configuration module by module to identify substructures. Following thedefinition of the s substructures above, there is no single unique way to group modules into substructures. This issuewarrants further discussion and is presented in Section 3.5.

Once the substructures have been identified, we treat all the modules in a given substructure as a distinct, atomic unit. We nolonger think of the configuration as a module graph, but having effectively partitioned the configuration into distinct groupsof modules, we now view it as a connected network of substructures (loops and chains), see Figure 4 below.

Once the configuration has been partitioned into substructures, we wish to describe how the substructures are connectedrelative to one another. In order to express a notion of order among the component substructures, we can describe theirrelative arrangement as a hierarchy, or tree. We can construct a “substructure tree” in a standard way [25] where eachsubstructure becomes a node of the tree. The procedure the algorithms follow to construct the tree is detailed in Section 3.4.

In moving from a network of substructures to a hierarchy, we are effectively transforming a graph into a tree. A tree is anordered, acyclic graph, meaning there must be no cycles between nodes (substructures). The choice of a loop as a basicelement in s effectively removes cycles. However, even if loops are part of s, there are still cases where cycles cannot beremoved by the partitioning, as would be the case in Figure 4. This occurs when substructures form cycles amongthemselves. Such cases require special treatment and are the subject of Section 3.6.

A hierarchical decomposition has several advantages. It allows for a concise, ordered description of a configuration in termsof levels and substructures per level. This ordering can be used by an algorithm to guide the reconfiguration in a systematicway, and to quantify the difference between a current configuration and its desired goal at any point during thereconfiguration process.

Furthermore, a hierarchy seems like the preferred architecture of complex systems, natural and artificial. Complex systemsmight, in general, be expected to be constructed, or decomposable, as a hierarchy of levels where the components performparticular sub-functions that contribute to the overall function. In nature, complex systems can evolve from simple systemsmore rapidly if there are stable intermediate configurations, which means the resulting complex form will be hierarchic. Thisargument has been put forward by several authors [22,23,24]. A complex Modular Robot configuration intended formanipulation or locomotion is also likely to be constructed hierarchically, with larger “macro” components performingcoarse motions and mounted “mini” components performing shorter range, higher-precision (high mechanical bandwidth)operations.

Page 1,Page 2

3.4 HSD-based Algorithms
We now present two self-reconfiguration algorithms. As a first step, both perform a decomposition step where I and G arehierarchically organized as a tree of substructures, as discussed in Section 3.3.2. As an illustration, consider I and G in Figure5a and 5b, and their corresponding decompositions. We will use these example configurations throughout the section toillustrate the algorithms.

1) Substructure selection.
The module-to-module connectivity of the configuration is traversed. A module is called a “vertex” module if it isconnected to more than two neighbor modules (is at a branch-out point) or to only one neighbor (is at a free end). All othermodules have two neighbors and lie between vertex modules.

A substructure is the shortest list of distinct modules lying between two vertex modules. If the two vertex modules are thesame, the substructure is of type loop. Conversely, if the vertices are distinct the type is chain. The special case of a singlecycle (with no vertex modules) is handled explicitly. A second step further creates loops by searching for cycles among theexisting chains. If there are any, all the chains involved in the cycle are now grouped together as a single loop substructureand no longer considered as a number individual chains.

Each substructure has an associated data structure containing the following information: size (number of modules in thesubstructure), type of substructure (chain or loop), pointers to neighbor substructures (other substructures connected at itsvertex modules).

2) Hierarchy creation
A substructure is selected as the root node (heuristics for this choice are discussed in Section 3.5). All neighborsubstructures become a child node of the root, and the root their parent node. The children’s children are recursivelysearched to create the corresponding parent/child relationships until childless nodes are reached.

Each node in the tree has an associated data structure that inherits the information of a substructure and the following: levelin the tree, pointer to its parent, pointers to all its children, and list of “attachment points”. We define attachment points asthe relative locations (vertex modules) on a substructure where its children nodes are attached.

Once hierarchically decomposed, I and G can be compared for equivalence, as defined in Section 3.2. Specifically, I and Gare equivalent if their trees are identical. That is, they have the same: 1) number of levels, 2) number of substructures perlevel, 3) type of substructures per level, 4) size of the substructures and 5) “attachment points” on each substructure.Conveniently, the difference between two configurations can also be quantified in terms of their respective trees, that is interms of the difference in the number of levels, number of substructures per level, etc. This measure of difference is used togenerate the sequence of precomputed substructure operations in the reconfiguration stage of the algorithms as explained inthe next section.

3.4.1 Canonical Form Algorithm
A very simple algorithm results in overall reconfiguration by first transforming into a simple intermediate configuration. It isbased on two observations: 1) the symmetry of reconfiguration sequences, that is, a sequence of rmoves that takes I to G canbe obtained by reversing the order of the sequence that transforms G to I; 2) “destructive” sequences that reconfigure acomplex configuration into a simpler one are easier to devise than vice versa.

Based on these observations, we find the sequence of rmoves to reconfigure both I and G into an intermediate simpleconfiguration, C. The reconfiguration from I to G is then:

The hierarchical decomposition is used to guide the sequence of operations needed to reconfigure I and G into C. If we selectC as a single chain then the reconfiguration stage is simply a concatenation of merge operations (retrieved from a lookuptable) resulting in ever decreasing number of levels and substructures.

This algorithm is, in general, sub-optimal as there may be redundant operations involved in going through the intermediateconfiguration. It is however, a very simple way to obtain otherwise difficult sequences of moves. It is an efficient heuristicsolution for cases where the I, G pair are close to the intermediate configuration. The Canonical Form algorithm is also likelyto perform better than the Matching algorithm presented below in cases where the latter requires many relocation operations,which may be more costly than the other substructure operations (see Section 3.3.1).

3.4.2 Matching Algorithm
This algorithm works by progressively matching the 5 equivalence conditions in Section 3.2. As a first step, the algorithmmatches the number of levels. In this case, G has a smaller number of levels than I. In order to reduce the number of levelsin I to match G’s, the algorithm invokes merge operations between the leaf nodes and their parent (lI - lG) times, where lGand lI are the number of levels in G and I respectively. Figure 7 shows the process.

Once the number of levels has been matched, the algorithm proceeds to match the number of modules at each level. Aseries of merge and split operations is invoked that effectively redistributes modules between levels. One pertinentobservation is that the number of modules per level need not be matched exactly. As long as the relative sizes are fairly close(90% was used in our implementation), the functionality will be the same and we can save extra reconfiguration operations.In this particular I, G pair, once I has reconfigured to have only two levels like G, the number of modules per level is deemedclose to the goal’s and no matching is

needed.

The type of substructures at every level is matched by invoking transformation operations to change a loop into a chain orvice versa. In the example shown, the types at every level already match those of the goal G and don’t require anytransformation operations.

As a last step, relocation operations attach the substructures at their goal attachment points on their parent. The relocationoperations involve, in general, the moving of a branch of the tree relative to the parent substructure. If the branch is severallevels deep and/or if the move is over a large distance, motion planning techniques must be brought to bear (see Section 2.4).This may result in these operations being costly or even unrealizable. However, if the relocation operations are simple, thisalgorithm will in general be more efficient than the Canonical Form algorithm, as it compares I and G for differences andseeks to make only those changes necessary to remove them.

3.5 Choices of Decomposition and Correspondence
It has been previously pointed out that following the definitions of s, chain and loop above, there are many different ways inwhich to group modules into substructures. An example is shown in the Figure 9. The number of different ways of selectingsubstructures is proportional to the number of ways of partitioning the associated module graph. This number increases withthe total number of modules.

This initial choice of substructures determines to a large extent the ensuing hierarchical decomposition. This means that for agiven I and G pair, there may be nI*nG different ways to partition both configurations into substructures, where nI and nG arethe number of different ways to select substructures in I and G respectively. There is, in addition, a choice involved in thecreation of the tree, as a particular substructure must be distinguished to be the root.

The simplicity of the reconfiguration sequence depends to a large extent on these choices. We can make use of a concept of“correspondence” (closeness) between I and G to result in a simpler reconfiguration. In particular, we wish to selectdecompositions that result in I and G having trees as similar as possible. For instance, for the Matching algorithm we wouldlike I and G to have:

• an equal (or as similar as possible) number of levels
• an equal (or as similar as possible) number of modules per level
• the same (or as similar as possible) number of substructures per level

We can use heuristics to guide the selection of the root. For example, we may select the largest substructure (largest numberof modules) to become the root in both I and G. This partly satisfies one of the correspondence rules above, and is resonantwith the macro-mini concept of complex hierarchical systems. Or alternatively, we could balance both trees to try to satisfythe first rule.

Although these criteria do not necessarily yield an optimal solution, they help to guide the decomposition towards choiceswith good correspondence between I and G, and so result in simpler reconfigurations. However, searching for the best I andG pair can be costly, since it implies creating all possible decompositions for both I and G and then searching for the bestpair among all (nI*nG ) choices. It is also possible to simply pick a choice “blindly” for both I and G and continue with thedecomposition, saving the cost of searching for the best correspondence.

3.6 Extensions
HSD analyses a network of substructures as a tree, which is an acyclic graph. By grouping modules in a cycle as a single loopsubstructure that becomes a node in the tree, we are effectively removing cycles from the graph. However, there are stillcases where cycles remain. These include cases when a substructure (loop or chain) connects to more than one point onanother substructure, or when it connects two substructures that belong to different levels. For example, this happens whenloops share common edges, or when there are cycles of substructures, as illustrated in Figure 10.

We call such substructures overconstrained, as an excess of connections causes the problem. The solution involvesselectively disconnecting one of the attachment points of the overconstrained substructure so that the cycle is effectivelyremoved and the tree can be constructed. Reverting to a module graph representation of a configuration (Section 3.2),overconstrained cases occur whenever the graph contains 3-connected minors, i.e. there exist pairs of vertex modules withthree or more distinct paths connecting them [26].

A clever choice of s may in some cases partly, or even entirely, avoid the problem. For example, we may select s to containa substructure equal to the first configuration shown in Figure 10. By encapsulating this particular topological grouping ofmodules as a single substructure with its associated operations, we effectively remove any such overconstrained substructuresfrom a global configuration.

One way to handle overconstrained I or G configurations in the planning is to form a virtual break in the overconstrainedsubstructures as they are discovered in the decomposition. This will produce I’ or G’, which are free of overconstrainedsubstructures. Planning can then happen normally between two non-overconstrained configurations. A step is added in thebeginning of the reconfiguration plan to transform I to I’ and a step at the end to transform G’ to G, as needed. This processis sub-optimal since it introduces additional rmoves and removes overconstrained configurations from the reconfigurationspace that may be indeed part of an optimal sequence.

3.7 Experimental Results
A computer simulation was run to test the HSD method. Several I,G pairs were used, the most complex configurationshaving up to four levels and twelve substructures. The desired goal configuration is achieved in all cases. One of the I,G pairstested is the example pair used to illustrate the method in Section 3. The sequence of rmoves output by the method leads tothe same changes shown in Figures 5-8, and these figures serve as illustration of the simulation results. Decompositions withoverconstrained substructures, and subsequently needing treatment as described in Section 3.6, were also tested.

4. CONCLUSIONS

This paper introduces a taxonomy of reconfiguration classes for modular, self-reconfigurable robots and defines theircharacteristics. A study of the closed-chain reconfiguration class, its topological space and suitable reconfigurationalgorithms are also presented. To the authors’ knowledge, this is the first time a reconfiguration approach has been publishedfor this class.

This paper introduces a heuristic approach called Hierarchical Substructure Decomposition (HSD). It centers on thepartitioning of a robot configuration into small components, called substructures, and their subsequent ordering as ahierarchy. Reconfiguration of the entire system is thus divided into a series of simple, precomputed reconfigurationsubsequences happening among the substructures.

Two algorithms based on HSD are described and simulation results discussed. The method presented outputs a sequence ofconnectivity changes to reconfigure between two arbitrary configurations. For the closed-chain class this sequence ofconnectivity changes must be accompanied by physically realizable trajectories for the moving kinematic chains. We do notaddress these considerations in the paper. As a next step, we intend to add a path planning stage to the method to producefeasible trajectories.

Page 1, Page 2

Tech Materials (Free)

Robot Behaviors Exploring the T-Maze: Evolving Learning-Like Robot Behaviors using CTRNNs
Humanoid Robotics A Biochemical Subsystem for a Humanoid Robot
Industrial Automation Systems Applying Agents for Engineering of Industrial Automation Systems
Robot Team Cooperation A Descriptive Model of Robot Team and the Dynamic Evolution of Robot Team Cooperation
Kuka Robots For ONU ONU Robotics Technology Center of Excellence, powered by KUKA Robotics Corporation
Augmented reality Annotation System for Robotic Application
Modular Robots Self-Reconfiguration Planning Of Identical Modules
Autonomous robots A New Approach To Robotics
Robotic Mounting Flat Panel Displays With Robotic Mounting
Calibration of Industrial Robots A Photogrammetric Robot Calibration System Based On Off-The-Shelf Low Cost Hardware Components

More...

Amazon Books

	Creative Projects with LEGO Mindstorms by Benjamin Erwin Buy new: $20.64 / Used from: $13.00 A good place to start, especially for kids, with Lego Mindstorms
	A Practical Guide to Behavior-Based Robotics by Joe Jones Buy new: $20.67 / Used from: $15.13 Very good for programming not so much behavior as control. Language and controller agnostic