A Graph Isomorphism-based Decentralized Algorithm for Modular Robot Configuration Formation
We consider the problem of configuration formation in modular robot systems where a set of modules that are initially in different configurations and located at different locations are required to assume appropriate positions so that they can get into a new, user-specified, target configuration. We propose a novel algorithm based on graph isomorphism, where the modules select locations or spots in the target configuration using a utility-based framework, while retaining their original configuration to the greatest extent possible, to reduce the time and energy required by the modules to assume the target configuration. We have shown analytically that our proposed algorithm is complete and guarantees a Pareto-optimal allocation. Experimental simulations of our algorithm with different number of modules in different initial configurations and located initially at different locations, show that the planning time of our algorithm is nominal (order of msec for modules). We have also compared our algorithm against a market-based allocation algorithm and shown that our proposed algorithm performs better in terms of time and number of messages exchanged.
Modular self-reconfigurable robots (MSRs)  are composed of individual robotic modules which can change their connections with each other to form different shapes or configurations. This configuration adaptability affords a high degree of dexterity and maneuverability to MSRs and makes them suitable for robotic applications such as inspection of engineering structures like pipelines , extra-terrestrial surface exploration , etc. A central problem in MSRs is to autonomously reconfigure the modules from one configuration to another . In this paper, we consider an aspect of this MSR reconfiguration problem called the configuration formation problem, which is described as follows: we are given a set of modules forming different configurations that are distributed at different locations within the environment along with a target configuration that needs to be formed at a specified location; the target configuration involves some or all of the modules from the initial configurations. The problem is to select an appropriate subset of modules to occupy appropriate spots or positions in the target configuration, so that, after reaching the selected positions, they can readily connect with adjacent modules and form the shape of the desired target configuration. An instance of this problem is shown in Figure 1.
Previous research in MSR configuration formation has mainly focused on the problem of self-reconfiguration, where the objective is to transform one configuration to another without removing or adding modules to the configuration; only the positions of the modules in the initial configuration are changed to obtain the target configuration. Our work in this paper generalizes the configuration formation problem to a scenario where the number of modules in the target configuration is independent of the number of modules in the initial configuration, and, individual modules or a connected set of modules can be extracted from multiple initial configurations to form the target configuration. The generalized configuration formation problem is non-trivial as the modules might already be connected in initial configurations that do not correspond to parts of the target configuration. Also, existing connections between modules in the initial configuration should be preserved in the target configuration, whenever possible, to reduce the energy and time expenditure in disconnecting and re-connecting modules. Moreover, multiple modules from different initial configurations might end up selecting the same most-preferred position (e.g., position involving least time and battery expenditure to navigate to) in the target configuration, leading to failed attempts to achieve the target configuration. To address these challenges, we propose an algorithm that allows modules from initial configurations to select suitable positions in a target configuration using a technique based on graph isomorphism that attempts to improve the utility of the modules by reducing the number of disconnects between modules to achieve the target configuration. We have shown analytically that our proposed algorithm is complete and achieves Pareto-optimal allocation. We have also verified the performance of our algorithm in terms of planning time and number of messages exchanged for different number of modules and different initial and target configurations, for simulated modules of the MSR. Our experimental results show that our algorithm performs better, in terms of planning time and number of messages passed by the modules as compared to a market-based allocation algorithm.
Ii Related Work
An excellent overview of the state of the art MSRs and their self-reconfiguration techniques is given in . One of the popular techniques for MSR self-reconfiguration is AI-based search techniques such as Rapidly-exploring Random Trees (RRT) and A* . However, as noted in a recent survey on MSRs , configuration formation in modular robot systems has been studied less extensively. Alonso-Mora et al.  addressed a position selection problem for artistic pattern formation by a swarm of robots where goal positions for robots are specified as Voronoi regions and the Hungarian algorithm  is used to allocate robots to goal positions. In , the authors have provided decentralized movement strategies for robots using random walk, systematic search, or, gradient-following to enable them to carry blocks to build user-specified configurations. A potential limitation of these approaches when applied to MSR configuration formation is that it would require modules already connected in a certain initial configuration to be first disconnected into singletons and then allocated to individual spots in the target configuration, resulting in unnecessary expenditure of energy to undock modules in the initial configuration and possibly re-dock the same modules in the target configuration; inter-module collision avoidance during locomotion of multiple individual modules would also consume more time and energy than when the same modules move together as a connected configuration. In contrast, our proposed approach attempts to preserve initial configurations in parts of the target configuration wherever possible using graph isomorphism  to avoid these issues. Graph isomorphism for MSRs has been investigated by several researchers [15, 16, 12], albeit for self-reconfiguring modules (changing positions of modules) that remain part of the same configuration after reconfiguration. Our proposed approach generalizes this direction of research by finding the best positions for multiple configurations and singleton modules within a different, possibly larger or smaller, target configuration.
Iii Configuration Formation as Utility Maximization Problem
Let denote a set of robot modules. Each has an initial pose denoted by , where denotes the location of and denotes its orientation within a 2-D plane corresponding to the environment. Each module has a unique identifier. A configuration is a set of modules that are physically connected. A configuration is denoted as . The topology of configuration is denoted as a graph, , where and . Each configuration has a module that is identified as a leader  and the leader’s pose is used to represent the configuration’s pose.
In the configuration generation problem studied in this paper, robot modules, starting from a set of different initial configurations, are required to get into a specified target configuration. The target configuration is also represented as a graph, denoted by , where is the set of vertices and is the set of edges. Each vertex in is referred to as a spot that a module needs to occupy and two neighboring spots share an edge between them depending on the topology of . Each spot is specified by its pose and its neighboring spots in the target configuration, , where . In the rest of the paper, for the sake of legibility, we have slightly abused the notation by using instead of to denote the target configuration and instead of to denote the spots in the target configuration.
To formulate the configuration generation problem as a utility maximization problem, we first represent the utility of a single module to occupy a single spot in the target configuration, and, then extend that representation to a set of modules connected as a configuration to occupy a set of adjacent spots in the target configuration. A single module’s utility for a spot is given by the value of the spot to the module minus the costs or energy expended by the module to occupy the spot. As reported in , the locomotion of an MSR is significantly affected by the locomotion of the module(s) in the MSR that has more neighbors in the MSR’s configuration. For example, for the target configuration shown in Figure 1(a), the module at the center of the -module configuration is more critical than the other modules for locomotion as it has more neighbors. To capture this position dependency, we have used a concept from graph theory called the betweenness centrality  to denote the value of spot , given by: where is the total number of shortest paths between any pair of nodes and in and is the number of shortest paths between and which go through . The cost to a module located at to occupy spot at , is calculated as a sum of ’s locomotion costs to reach and occupy spot , and any costs to undock and re-dock with neighboring modules before and after it occupies the spot . This is denoted as , where denotes the locomotion cost from to , denotes the cost of docking with modules in neighboring spots of and denotes the undocking costs of from neighboring modules in . Note that energy requirements for locomotion of a module are generally higher than those for docking the module with another module as locomotion requires continuous power to all motors and much higher torques than docking; also, docking two modules requires aligning their docking ports first, which takes more energy than un-docking two modules. Therefore, .
When a set of modules is connected in configuration , the cost of occupying a set of spots in the target configuration is given by: , where is a reward function for retaining connections between modules in the existing configuration into smaller configurations. Because increases (and decreases) with the size of , it is cost-wise better to break smaller configurations than to break larger configurations to fit into the target configuration. So, the reward function ensures that keeping the initial configuration intact in the target configuration, whenever possible, results in lower cost. Using the above formulation, it can easily be seen that when can fit entirely into (i.e., ), .
The utility of a spot to a module determines how profitable or beneficial that spot is for the module if it finally ends up occupying that spot. The utility of module for spot is given by . Similar to the cost function described above, the utility for initial configuration to occupy a set of spots , is given by the sum of the utilities of the individual modules comprising to occupy spots in , . Using the above formulation, the spot allocation problem has to assign modules to spots so that each module is allocated to the most eligible (highest utility earning) spot and no two modules are assigned to the same spot. Given a set of modules in a set of initial configurations, and, a set of spots representing the target configuration, find a suitable allocation such that and . Note that, if two modules and both have the same highest utility for spot , then only one of them can be allocated to and occupy . In the next section, we describe our spot selection algorithm that provides a suitable allocation of modules to spots for the above utility maximization problem.
Iv Spot Selection Algorithm
We divide the problem into two phases - a planning phase, where modules select spots in the target configuration, and an acting phase, where modules move to their selected spots and connect with other modules.
Iv-a Planning Phase
In the beginning of the planning phase, all the modules broadcast their positions and orientations. After having this information, each module calculates the location corresponding to the center target configuration in the environment, as the mean of all spots’ positions.111A common coordinate system can be maintained by modules for localizing themselves following the model described in . Individual modules then rank themselves according to their distances from the center of ; the rank of a configuration is calculated using the distance of the configuration’s leader from the center of . Modules and configurations select spots in based on their rank. Because has the most significant contribution to the cost function, the distance-based rank ensures that modules and configurations with lower costs (higher utilities) get to select spots in first. We describe the spot selection techniques in the planning phase in two parts - spot selection by singleton modules and spot selection by configurations.
Iv-A1 Spot Selection by Singleton Modules
A singleton module selects a spot to occupy using Algorithm LABEL:algo_singleton. first sorts the spots in order of its expected utility . If a spot has not already been selected by another module, or, if it has been selected by another singleton module (module that is not part of a configuration) that can be evicted using the evict method, then selects and broadcasts the updated spot-selector pairs to all other modules. If cannot evict the module currently occupying its highest utility spot, then it successively reattempts spot selection using the spots for which it has the next highest utilities. If none of the spots in can be selected by , it broadcasts a NO_SPOT_FOUND message to all other modules.
The evict method is used by module to cancel the selection of spot done previously by another singleton module . Note that eviction can be done only for a singleton module, and not for modules that are part of configurations, as breaking existing configurations will incur additional time as well as costs for docking and undocking modules. The method first checks the expected combined utility between and for selecting their most (conflicting) and second-most preferred spots. If this combined utility is greater when selects and selects its next highest utility spot that it can occupy, then evicts the selection of by , as shown in the evict() method in Algorithm LABEL:algo_singleton. To limit excessively long cycles of eviction, we have allowed at most successive evictions. An illustration of the eviction process with is shown in Figure 2.
Iv-A2 Block Allocation by Modules Connected in a Configuration
The technique used by configuration to select a set of connected spots in the target configuration is given by the blockAllocation algorithm shown in Algorithm LABEL:algo_configuration. The algorithm is executed on , the leader of configuration , selected using techniques in .
To place into without breaking the connections between its modules, we have to find if , or a subgraph of , is isomorphic to 222Note that if then the problem becomes a graph isomorphism problem. An example of this problem is shown in Figure 3(a) that shows all possible subgraphs of which are isomorphic to the configuration using different colors. This problem requires finding the isomorphic subgraphs (IS)  of ; it is an NP-hard problem but can be solved in polynomial-time for certain graph structures like trees . However, if is not isomorphic to or a subgraph of , then can not be placed into without breaking its connections and, thus, changing its shape. In such a scenario, our objective is to reduce the number of connections that are removed between ’s modules. For this, we have to find the maximum number of modules in , which can be placed directly into , without first disconnecting them. An example is shown in Figure 3(b), where the red dotted boxes indicate the maximum common subgraphs of and , which are isomorphic. This problem is an instance of the maximum common subgraph (MCS) isomorphism problem , where, given two graphs and , the goal is to find the largest subgraph which is isomorphic both to a subgraph of and . 333If , then we find the maximum size subgraph of which is isomorphic to and allocate the spots to matched modules, using a similar technique as in blockAllocation algorithm.
Our algorithm first finds subgraphs of that are isomorphic to . If there are no isomorphic subgraphs, it checks for maximal common isomorphic subgraphs. These subgraphs are stored in set (lines ). As modules want to maximize the utility earned from the allocation, the subgraphs within are ordered by utility to . The algorithm then inspects each subgraph . If all the spots in are free, then is selected by and broadcasts a message to notify every module in about this selection (lines ). On the other hand, if any spot is already selected by a singleton , checks to see if it can evict using the evict() method. If evict is successful, is selected for and the updated set of spot-selector pairs are broadcast to all modules in (lines ). If eviction is not successful, it means that some modules in could not occupy some spots in the target configuration (or its subgraph) as some other modules that did not belong to configuration had already selected those spots. In this case, the modules of that could not find a spot in will be disconnected from . Single spot selection algorithm is then used to select other spots in for these modules (lines ). Finally, because selection of by a configuration is done by means of matching modules of to unique spots in , if is an MCS of (i.e., , then some of the modules in will not be matched to any spot in . Those unmatched modules will disconnect from , become singletons and will execute singleton module spotAllocation() algorithm, in the order of their distances from the center of , to get allocated to a spot (lines ). Note that all other modules in whose matched spots in were free to occupy, will occupy the matched spots while retaining their configuration. The updated set of spot-selector pairs are broadcast to all modules.
Iv-B Acting Phase
After the planning phase is finished and all the spots in the target configuration have been selected by modules, the modules have to move to their respective selected spots. Note that no robot moves until all the spots are selected. If there is no proper order of robots for assuming spots, then a deadlock situation might arise. For example, in Figure 1(b), if all the modules occupy their spots before module does, assuming module is a singleton, then it will be difficult for module to occupy its spot properly, unless other modules give it space for moving. But then they will have to align themselves again, which is a difficult task. To avoid this, the module which has selected the spot with highest betweenness centrality value (or, central spot), will move first and assume its position. Once it is in its proper position, it will broadcast a message to notify this to all other modules. Next the spots neighboring the center spot will be filled and so on. Techniques described in  can be used for locomotion of the modules.
spotAllocation and blockAllocation algorithms are complete when sufficient number of modules are available to form desired target configuration.
Proof: We prove the completeness of the algorithms by showing that there is no empty spot or hole in the target configuration when the number of modules is at least equal to the number of spots in the target configuration , i.e., when . A hole exists in if there is a spot that is not occupied by any module. This can happen because of two conditions: ) No module has selected , or, ) module , which selected , could not reach its spot because another module blocked the path to its selected spot by occupying a spot that was further from the center of than the selected spot. We show that these two conditions cannot arise. If , then because of the recursive approach in the evict method of Algorithm LABEL:algo_singleton, each module will try to select a spot in , as long as there are available spots. This guarantees that condition never arises as at least one module will select . Condition will never arise because, as described in Section IV-B, modules’ priority to move is based on the betweenness centrality of their selected spots, and, spots nearer to the center of are occupied first, followed by outer ones. In other words, no module will occupy an outer spot before its neighboring spot, that is nearer to the center of the target configuration gets occupied. Consequently, cannot have a hole. Hence proved.
spotAllocation algorithm returns a Pareto-optimal allocation between modules and spots, i.e., any module’s earned utility cannot be improved without making another module’s utility worse.
Proof: Let denote the -th highest utility spot for module . Because each module orders the spots based on utilities, it follows that . Consider two modules and that have the highest utility for the same spot (i.e., , but . Also, assume that has selected spot first. Now, if spotAllocation allocates to its next best spot, and remains at , then the total utility is . On the other hand, if spotAllocation method evicts from and allocates it to its next best spot (assuming it is free), then the total utility becomes . From Algorithm LABEL:algo_singleton, if eviction is possible, then . On the other hand, if eviction does not happen, then it implies, . For any other allocation strategy that does not do eviction even if , then the total utility earned by the alternate allocation strategy is always less than the utility earned by spotAllocation algorithm. From the above equations, we can conclude that, if any two modules and have same ranking for a particular spot, , then one of the modules will be allocated to that spot and the other will be pushed to its next highest utility spot, i.e., its earned utility reduces, and no other allocation would increase their utilities as well as the overall utility. Hence the allocation strategy is Pareto-optimal.
As approaches —S—, the total utility earned by the modules () approaches the optimal utility .
Proof: If there is no conflict among the modules about their best spots, i.e., each module’s highest utility spot is unique, then spotAllocation algorithm allocates highest utility spots to all the modules and thus achieves the optimal utility. But if there is a conflict among modules for the same spots, then eviction method is invoked. From Algorithm LABEL:algo_singleton, we can conclude that the total utility earned by the modules increases by successively calling the evict method. For , any subsequent evictions will consequently increase the total utility. If eviction fails, then that means the total utility can not be improved any further. Thus, every time the eviction method is invoked it will increase the total utility, going towards the optimal utility.
Note on complexity. The spotAllocation algorithm (Algo. LABEL:algo_singleton) has a time complexity given by where is the number of spots in the target configuration and is the depth up to which the eviction of modules is allowed. In the blockAllocation algorithm (Algo. LABEL:algo_configuration), target configurations are considered to be trees and finding all possible isomorphic subtrees in the target configuration has a polynomial worst case time complexity of , where and are the number of modules and spots in intial and target configurations respectively, and, is the maximum branch factor of either configuration ( for our MSR).
V Experimental Evaluation
Settings. We have implemented the spot allocation algorithm on a desktop PC (Intel Core i5 -960 3.20GHz, 6GB DDR3 SDRAM). We tested instances where random number of singletons and the initial configurations with sizes between and modules need to be allocated to target configurations with between and spots. In all cases, unless otherwise mentioned, the total number of modules in the environment is equal to the total number of spots in the target configuration. Each module is modeled as a cube of size unit unit unit. The modules are placed at random locations within a unit unit environment, their initial orientations are drawn from a uniform distribution in , and the initial positions of singletons and leaders of the initial configurations are drawn uniformly from . For all the tests, has been set to . Changing the value of from to affected the algorithm’s performance (both time and quality wise) negligibly; therefore this is not included in the results.
Initial and target configurations were restricted to be trees based on the connections the modules in our MSR platform are capable of, although our algorithms can be applied for any other kinds of graphs as well. As there can be numerous subtrees present in the target configuration, which are isomorphic to the initial configuration and finding all possible isomorphic subtrees can take considerable time, we set an upper bound, , on the number of isomorphic subtrees that the blockAllocation algorithm (Algo LABEL:algo_configuration) will check. is set to to ; different values of or did not change the performance of the algorithm. To get higher utility isomorphic subtrees, first the nodes in the target configuration are sorted in descending order of betweenness centrality values, because if the costs to occupy two different spots are the same, then higher betweenness centrality (spot value) indicates higher utility of the spot. For every node in the sorted list of spots, every node in current configuration is made the root of once and checked for subtree isomorphism with target configuration while making each node in the root once, for every possible tree in . The checking of isomorphic subtrees between and is stopped as soon as the first isomorphic subtrees are found. All results are averaged over runs.
Results. Performance Analysis of Our Approach: First we have shown how much time it takes to find number of MCS (or, IS). The result is shown in Figure 4(a). The -axis denotes the size of a single configuration and the -axis denotes the time in milliseconds to find number of MCS (or, IS) of that configuration in the target configuration. For this test, total spots in the target configuration have been set to . Though the run time increases with the size of the initial configuration, which can be expected because of the complexity results shown in  for finding isomorphic subtrees, but still it was always well within a reasonable bound.
In the next set of experiments, we have focused on the main contribution of this paper - how to construct a modular robotic system from an initial set of singletons and configurations. Figure 4(b) shows how the planning time changes with different number of modules; the -axis denotes the total planning time in milliseconds and the -axis denotes the number of robots. It can be noted from this plot that though for a small set of robots, time change is almost constant, as the configuration size as well as the number of robots increases, elapsed time increases in a polynomial fashion. This elapsed time indicates only the planning phase execution time of the robots. Figure 5(a) shows how with increasing number of robots the total distance traveled by them changes. This metric is calculated by adding the distances traveled by each module from their initial positions to their respective spots in . The figure shows that the total distance traveled by the robots increases linearly. We have also calculated the total number of messages passed among robots while the configuration formation process is occurring. Figure 5(b) shows how the number of total messages changes with the number of robots. As can be expected, with a higher number of modules in the environment, the number of messages increases in a polynomial fashion.
Figure 6(a) shows the planning completion rate for different number of robots between and . We can see that with increasing number of robots, the completion rate increases and is more evenly distributed over time. For instance, with , after time completion, only of planning has been completed, whereas with , of planning gets completed only after of time completion. The relationship between planning phase completion and number of passed messages for modules has been shown in Figure 6(b). All the graphs from runs have been plotted. We observe that the message count is increasing almost-linearly with completion rate. For the next set of experiments, we have kept the number of spots, , fixed at and we have varied the number of robots between . Figure 7(a) shows planning completion rate for different numbers of robots. We can see that with increasing number of robots, completion rate increases and is more evenly distributed over time. This behavior is similar to what we have seen in Figure 6(a). Although in Figure 6(a), for most of the robot sets, the planning phase completes almost at the end of their respective time-lines, but in the case of Figure 7(a), we can notice that the planning phase finishes at different stages of their time-lines, for different numbers of robots. As an example, for , the planning phase almost converges at the of total elapsed time, whereas for , it takes almost time to converge.
Figure 7(b) shows the comparison of the number of passed messages by the different numbers of robots, between the cases where and . It can be observed from this figure that with same number of robots, fewer messages are passed if there are fewer spots than robots, i.e., if . For example, with, and , messages are passed, whereas with and keeping fixed to , the number of messages increases to . This result shows that the total number of messages depends on both the number of robots and spots.
|Size of All||Planning Time||No. of Modules|
|10||171.48 (avg.)||0.12 (avg.)|
|15.13 (std.)||0.32 (std.)|
|20||166.66 (avg.)||4.32 (avg.)|
|12.88 (std.)||3.56 (std.)|
|25||172.10 (avg.)||8.76 (avg.)|
|11.30 (std.)||4.85 (std.)|
|50||218.28 (avg.)||29.68 (avg.)|
|19.57 (std.)||5.33 (std.)|
Next we have run experiments to check how the subgraph isomorphism technique used in this work helps to reduce the number of disconnections from initial configurations. For this test, we have kept . Initially all modules were part of some smaller configurations and each initial configuration has the same size. We have varied the sizes of each initial configuration between and thus in these cases the number of initial configurations have been varied between . The planning times and number of modules required to be disconnected for these cases are shown in Table I. As can be seen, with increasing size of initial configurations, number of disconnected modules increases. This is because the probability of finding isomorphic subgraphs in decreases with increasing size of initial configurations. But the low number of disconnected modules show that it is always beneficial, in terms of number of connections detachments and re-attachments, to use our proposed approach than to break all initial configurations into singletons and then form the target configurations with them.
Comparison with Auction-based Allocation. We have also compared our approach for MSR configuration formation with an auction algorithm  that finds an optimal assignment between spots and modules. Using the auction mechanism a group of modules bid for a set of spots. First the modules bid for their most preferred spots; conflict among modules for the same spot is resolved by revising bids in successive iterations. The assignment is done in a way such that the utility is maximized. The auction algorithm does not take connected configurations of modules during allocation. Therefore only for the tests which compare the performances of our algorithm against the auction algorithm, initially all the modules are considered to be singletons. A log scale comparison of planning times between spot allocation and the auction algorithms is shown in Figure 8(a). As can be seen from this graph, with increasing the number of robots, the difference between planning times of these two algorithms increases, i.e., our proposed algorithm’s performance gets better with increased number of robots compared to the auction algorithm. Comparison of distances traveled by the modules using our algorithm and the auction algorithm is shown in Figure 8(b). As we can see in this plot, in most of the cases total traveled distance by the robots is the same. But with higher numbers of robots, using the proposed spot allocation algorithm robots travel less distance than by using the auction algorithm. Thus the spot allocation algorithm assigns the spots to the modules in very nominal time, keeping the cost for movement almost the same (or less in some cases), compared to the auction algorithm. A log scale comparison of number of the messages generated, by the spot allocation and auction algorithms, is shown in Figure 9(a). This figure indicates that the spot allocation algorithm generates fewer messages than the auction algorithm, which helps to reduce the communication overhead. Figure 9(b) compares the completion rates of planning phases of the auction and spot allocation algorithms - the -axis denotes the percentage of total time elapsed. This result indicates that completion rate of the auction algorithm is higher, even though the auction algorithm takes longer than the spot allocation algorithm.
|Case : Planning Time: ms., No. of disconnections:||Case : Planning Time: ms., No. of disconnections:|
|Case : Planning Time: ms., No. of disconnections:||Case : Planning Time: ms., No. of disconnections:|
|Case : Planning Time: ms., No. of disconnections:||Case : Planning Time: ms., No. of disconnections:|
|Case : Planning Time: ms., No. of disconnections:||Case : Planning Time: ms., No. of disconnections:|
V-a Case Studies
In this section, we have shown specific cases of the configuration formation process that are shown in Figure 10. Each of the initial and target configurations used for this set of experiments have been shown to be feasible and stable in . Squares represent the modules and the links between two squares denote the connection between those two modules. For each case illustrated, the left-most diagram shows the initial configurations and/or singletons, the middle diagram shows the detected MCS (or, IS) and the diagram on the right shows the final formed configuration. The modules are color-coded to show the final allocations. MCS (or, IS) are shown with dotted boxes. Grey-colored modules represent the modules that remain connected to the same neighboring module between initial and target configurations, but only change the connector through which they are connected. Although this operation requires one undocking and one redocking operation, it consumes less energy than if the module were to be connected to a non-neighbor module. The planning time and number of disconnections for each case are provided alongside each configuration formation case in Figure 10. We can see that each of the test cases requires less than milliseconds of planning time. Target configurations are also formed with relatively low number link disconnections (maximum being ).
Vi Conclusion and Future Work
In this paper, we have proposed a novel spot allocation algorithms for configuration formation in MSRs. In the future, we are planning to add uncertainty in module’s movements and an MDP-based technique for the planning phase of our algorithm. We also plan to consider the problem where there could be multiple target configurations and each module needs to decide which spot in which target configuration they should select. We are also planning to investigate algorithms that optimize the battery spent in getting to the target configuration and investigate the trade-off between aborting target configurations and saving battery. Finally we are working on implementing this algorithm on physical MSR hardware.
-  H. Ahmadzadeh and E. Masehian. Modular robotic systems: Methods and algorithms for abstraction, planning, control, and synchronization. Artificial Intelligence, 223:27–64, 2015.
-  J. Alonso-Mora, A. Breitenmoser, M. Rufli, R. Siegwart, and P. Beardsley. Multi-robot system for artistic pattern formation. In Robotics and Automation (ICRA), 2011 IEEE International Conference on, pages 4512–4517. IEEE, 2011.
-  J. Baca, S. Hossain, P. Dasgupta, C. A. Nelson, and A. Dutta. Modred: Hardware design and reconfiguration planning for a high dexterity modular self-reconfigurable robot for extra-terrestrial exploration. Robotics and Autonomous Systems, 62(7):1002–1015, 2014.
-  J. Baca, B. Woosley, P. Dasgupta, A. Dutta, and C. Nelson. Coordination of modular robots by means of topology discovery and leader election: Improvement of the locomotion case. In Distributed Autonomous Robotics Systems (DARS). DARS, 2014.
-  D. P. Bertsekas. The auction algorithm for assignment and other network flow problems: A tutorial. Interfaces, 20(4):133–149, 1990.
-  U. Brandes. A faster algorithm for betweenness centrality. Journal of Mathematical Sociology, 25(2):163–177, 2001.
-  D. Brandt. Comparison of a and rrt-connect motion planning techniques for self-reconfiguration planning. In Intelligent Robots and Systems, 2006 IEEE/RSJ International Conference on, pages 892–897, Oct 2006.
-  S. Chien. The eo-1 autonomous sciencecraft and prospects for future autonomous space exploration. 2005.
-  L. P. Cordella, P. Foggia, C. Sansone, and M. Vento. A (sub) graph isomorphism algorithm for matching large graphs. Pattern Analysis and Machine Intelligence, IEEE Transactions on, 26(10):1367–1372, 2004.
-  P. Dasgupta, V. Ufimtsev, C. Nelson, and S. M. G. Mamur. Dynamic reconfiguration in modular robots using graph partitioning-based coalitions. In AAMAS, pages 121–128. Valencia, Spain, 2012.
-  F. Enner, D. Rollinson, and H. Choset. Motion estimation of snake robots in straight pipes. In International Conference on Robotics and Automation, pages 5148–5153, 2013.
-  F. Hou and W.-M. Shen. Graph-based optimal reconfiguration planning for self-reconfigurable robots. Robotics and Autonomous Systems, 62(7):1047–1059, 2014.
-  A. Kamimura, H. Kurokawa, E. Yoshida, K. Tomita, S. Kokaji, and S. Murata. Distributed adaptive locomotion by a modular robotic system, m-tran ii. In Intelligent Robots and Systems, 2004.(IROS 2004). Proceedings. 2004 IEEE/RSJ International Conference on, volume 3, pages 2370–2377. IEEE, 2004.
-  H. Kuhn. The hungarian method for the assignment problem. Naval research logistics quarterly, 2(1-2):83–97, 1955.
-  C. A. Nelson and R. J. Cipra. An algorithm for efficient self-reconfiguration of chain-type unit-modular robots. In ASME 2004 International Design Engineering Technical Conferences and Computers and Information in Engineering Conference, pages 1283–1291. American Society of Mechanical Engineers, 2004.
-  M. Park, S. Chitta, A. Teichman, and M. Yim. Automatic configuration recognition methods in modular robots. The International Journal of Robotics Research, 27(3-4):403–421, 2008.
-  J. W. Raymond and P. Willett. Maximum common subgraph isomorphism algorithms for the matching of chemical structures. Journal of computer-aided molecular design, 16(7):521–533, 2002.
-  Redacted.
-  R. Shamir and D. Tsur. Faster subtree isomorphism. In Theory of Computing and Systems, 1997., Proceedings of the Fifth Israeli Symposium on, pages 126–131. IEEE, 1997.
-  K. Stoy, D. Brandt, and D. Christensen. Self-Reconfigurable Robots: An Introduction. Cambridge, Massachusetts: The MIT Press, 2010.
-  I. Suzuki and M. Yamashita. Agreement on a common x-y coordinate system by a group of mobile robots. In Intelligent Robots, pages 305–321, 1996.
-  J. Werfel and R. Nagpal. Three-dimensional construction with mobile robots and modular blocks. The International Journal of Robotics Research, 27(3-4):463–479, 2008.
-  M. Yim and et al. Modular self-reconfigurable robot systems: Challenges and opportunities for the future. IEEE Robotics and Automation Magazine, 14(1):43–53, 2007.