A hierarchical CSP search for path planning of cooperating self-reconfigurable mobile fixtures

Engineering Applications of Artificial Intelligence 34 (2014) 85–98

Contents lists available at ScienceDirect

Engineering Applications of Artificial Intelligence journal homepage: www.elsevier.com/locate/engappai

A hierarchical CSP search for path planning of cooperating self-reconfigurable mobile fixtures Włodzimierz Kasprzak a,n, Wojciech Szynkiewicz a, Dimiter Zlatanov b, Teresa Zielińska c a

Institute of Control and Computation Engineering, Warsaw University of Technology, ul.Nowowiejska 15/19, 00-665 Warszawa, Poland PMAR Laboratory, DIMEC, University of Genoa, Via all'Opera Pia 15a, 16145 Genoa, Italy c Institute of Aeronautics and Applied Mechanics, Warsaw University of Technology, ul.Nowowiejska 24, 00-665 Warszawa, Poland b

art ic l e i nf o

a b s t r a c t

Article history: Received 19 April 2013 Received in revised form 21 March 2014 Accepted 15 May 2014

The paper presents the application of artificial intelligence tools for the path planning of complex multiagent robotic systems. In particular, a solution is proposed to the planning problem for the conjoint operation of two or more mobile robotic fixtures used for the manufacturing of large workpieces, like those used in the aerospace industry. Such fixturing systems have been recently designed and tested, raising hopes to better satisfy the dynamic conditions of modern manufacturing, with its increasing emphasis on flexibility, adaptability, and automation. The proposed planning method is novel in two fundamental aspects. First, it interprets planning as a constraint satisfaction problem (CSP), rather than as a constrained optimisation, an approach ubiquitous in the path and motion planning literature. Secondly, the formulated CSP is solved by a hierarchy of incremental state space search algorithms which differ in some way from the existing state of the art. This hierarchy includes levels related to the robot and workpiece arrangement parameters and to three components of mobile fixture agents: a supporting head, a mobile base, and a parallel manipulator, respectively. Due to the use of CSP search, the planner constitutes a largely application-independent framework, on the basis of which specific industrial implementations can be defined by supplying the relevant physical, geometrical, and time-related constraints. & 2014 Elsevier Ltd. All rights reserved.

Keywords: Action planning Active supports Constraint satisfaction Hierarchic CSP Mobile robots Partial CSP

1. Introduction A fixture is a device for locating, constraining, and adequately supporting a deformable workpiece during a manufacturing operation (Bi and Zhang, 2001). In keeping with current trends in manufacturing, fixture systems are gradually being transformed to allow increased flexibility, reconfigurability, and automation (Boyle et al., 2011; Leitao et al., 2012). A recent example of such approach is the self-reconfigurable fixture system, developed within the European SwarmItFIX project (de Leonardo Girard et al., 2013; Zieliński et al., 2013), primarily targeted at the aerospace industry. The system uses mobile robotic fixture agents continuously repositioning to provide support to the thin-sheet workpiece near the moving machine tool (Fig. 1). Hereafter, the term agent refers to a single mobile fixturing robot consisting of a mobile base, a parallel kinematic machine (PKM) and an adaptable head. This automation solution has undeniable industrial appeal as it n

Corresponding author. Tel.: þ 48 22 825 09 95; fax þ 48 22 825 3719. E-mail addresses: [email protected] (W. Kasprzak), [email protected] (W. Szynkiewicz), [email protected] (D. Zlatanov), [email protected] (T. Zielińska). http://dx.doi.org/10.1016/j.engappai.2014.05.013 0952-1976/& 2014 Elsevier Ltd. All rights reserved.

eliminates the need for the costly dedicated solid-mold fixtures currently used for the manufacturing of large thin airplane parts, with the associated increases in production time and the required storage space. A key issue for the viability of such an autonomous fixturing system is the ability to reliably and automatically generate complete time-dependent path (or motion) plans for the agents' actions (Gonzalez-Rodriguez, 2011). For a highly reconfigurable system such as SwarmItFIX, the typical combinatorial or globaloptimisation approaches (Choset et al., 2005; LaValle, 2006) to fixture planning are of high complexity because of the presence of numerous and non-comparable criteria, related to task description, robot design or workpiece arrangement. The emphasis shifts from the search of an optimum to the satisfaction of constraints and a discrete variable setting. Therefore, a natural approach to such a planning task is to view it as a multi-agent constraint satisfaction problem and to modify the solution techniques of discrete constraint satisfaction problems (CSP) (Russel and Norvig, 2002; Salido et al., 2008). In a classic CSP the problem is represented in terms of state variables which satisfy a given set of constraints (a graph of constraints). A state consists of a finite set of variables, to which eventually values from finite domains are assigned. A solution to a CSP is every complete state (with values

86

W. Kasprzak et al. / Engineering Applications of Artificial Intelligence 34 (2014) 85–98

Fig. 1. The real arrangement of the system (the bench and two mobile agents) in a factory.

assigned to all variables) which satisfies the graph of constraints. Having defined such a model of the problem, an applicationindependent re-usable search algorithm can be designed. To get a complete solution algorithm, it is sufficient to fit the search-based control with some agent-dependent data and functions, related to single-variable assignments and constraints. For the solution of a CSP problem two classes of search algorithms are generally possible: (1) incremental state search – a depth-first search with backtracking, improved by local ordering of variables and values, and by path prediction (Kondrak and van Beek, 1997), or (2) complete state search – an informed search, with a global fringe (e.g. An search), stochastic fringe (e.g. simulated annealing) or a local fringe (e.g. hill climbing) (Russel and Norvig, 2002). An is an optimal graph search algorithm but only under consistent heuristics (Pearl, 1984). If for some application the design of a “good” heuristic judgment is not possible, but one wants to keep the search complexity sufficiently low, locally optimal search (Korf, 1990) and hybrid methods (optimal search combined with depth-first search) (Chakrabarti, 1989) can be applied. A hierarchical decomposition of the application domain has been proposed in Papadias et al. (1999) in order to efficiently guide a CSP search. According to Papadias et al. it is most useful in applications where the number of variables is relatively small (e.g. less than ten), while the domains of values are very large (e.g. more than 100,000 values). Because of this large amount of data a domain decomposition, driven by an appropriate indexing scheme, seems to be an obvious need and this approach has been used to speed up the process of database queries. However, in all existing applications a single CSP process is performed and a single CSP-search tree is managed. Hence, there is a need for significant change of any type of CSP-search algorithm, to make it dependent on an R-tree for domain decomposition, and to specify subproblems within a single CSP process, as every level of the search tree operates on different sub-domains of the variable. The authors of Papadias et al. (1999) tested several algorithms while focusing of incremental search with the forward checking technique and a local search with a min-conflict heuristics. The experiments have shown an advantage of the hierarchical CSP but only with a small number of discrete variables (less than 10) with a sufficiently large domain (more than 105 values). Multi-agent planning problems are naturally described as distributed constraint satisfaction problems (distributed CSPs) (Yokoo et al., 1998), like problems of distributed task scheduling and resource allocation in information systems (Salido and Giret,)

or the multi-agent truth-maintenance task in AI applications (Yokoo and Hirayama, 2000). In a distributed CSP, variables and constraints are distributed among multiple agents. A solution to a distributed CSP is a set of values to distributed variables that satisfies all distributed constraints. A solution to a distributed CSP is not equivalent to a distributed or parallel search. Indeed, in a distributed CSP the distribution of problems is given in advance, whereas in distributed/parallel search any distribution of the problem can be chosen. Sometimes a CSP can be overconstrained so that no complete solution exists. It has been proposed to deliver at least a partial solution to over-constrained CSPs (Freuder and Wallace, 1992), distributed CSPs (Hirayama and Yokoo, 1997) and also similarly to handle hierarchical distributed CSPs (Hirayama and Yokoo, 2000). In partial CSP, one tries to find assignments that minimise the importance value of violated constraints. This is achieved by employing a problem relaxation technique expressed in terms of removing constraints. Hence, the basic CSP is extended to a partial CSP by defining a set of relaxed CSPs and a partial order over them based on a distance function. Additionally, necessary and sufficient bounds on the distance between an original CSP and some solvable (partial) CSP are defined. A solution to a partial CSP is a combination of a solvable CSP and its solution, where the distance between an original CSP and the solvable CSP is less than the necessary bound. Any partial solution will suffice if the distance value is not greater than the sufficient bound. An optimal partial solution has a minimum distance value. The extension of partial CSP to a multi-agent partial CSP is straightforward (Hirayama and Yokoo, 1997), as for every individual CSP (one per agent) a corresponding partial CSP is defined, as given above, and a global distance metric is also defined, that combines the distance values of individual partial CSPs. An optimal partial solution has a minimum global distance value. When combining multi-agent (distributed) partial CSP with a hierarchical approach, it was proposed to build the hierarchy of relaxed CSPs by defining importance values of individual constraints (Hirayama and Yokoo, 2000). Thus, the particular agents try to find assignments that minimise the maximum importance value of violated constraints over agents. Let us observe that our specific application problem (and also many other industrial applications) can be considered both as a multi-agent planning (because at least two mobile supports are needed) and a hierarchic planning problem (because each agent is composed of three main mobile parts). To find a path and time plan for several constrained parts of several agents means here to find a consistent and timely synchronised combination of actions under some inner agent's constraints (workspaces of parts, motion constraints), between-agent constraints (collision-free paths) and outer constraints (due to the workpiece and CNC machining process). A natural consequence is to handle the planning problem as a hierarchic CSP (but with the decomposition made according to parts and not agents) and a partial CSP (but without direct relaxation of the constraints, while finding a subset of consistent variable assignments). The remainder of the paper is organised as follows. The industrial application case – the design of cooperating fixturing agents and their general path and time planner are presented in Section 2. The hierarchic CSP framework – its applicationindependent search algorithms and required problem definition interface – is presented in Section 3. It is also introduced how the particular path planning problem can fit into this general framework. A detailed implementation of the path planner in terms of the hierarchic CSP framework is the scope of Section 4. Particular agent-dependent constraints and functions needed to represent the search space for the mobile fixtures are given. Examples of experiments are presented in Section 5. The final section presents conclusions of this work.

W. Kasprzak et al. / Engineering Applications of Artificial Intelligence 34 (2014) 85–98

2. The application problem 2.1. Cooperating mobile fixtures The industrial application is illustrated in Fig. 1. The machined object is a stationary thin-sheet workpiece, which is subject to a sequence of processes (such as milling, holing, or drilling) by a moving machine tool, i.e. an instance of the general task. The part is held in place by a limited number of static fixtures (Fig. 1) that can support its weight but cannot adequately resist the large machining forces. The latter task is fulfilled by two (or more) mobile robotic agents that follow the progress of the machine tool and alternate to provide support of the piece in the immediate vicinity of the machined area. As mentioned above, every mobile unit, referred to as a physical agent, is composed of a mobile platform, a parallel kinematic machine (PKM) (Neumann, 2008) fixed to the mobile platform, and an adaptable head (Avvenente et al., 2010; Molfino and Molfino, 2011). The manipulator is placed on a mobile base capable of rapid locomotion along and secure instant docking to a flat (but not necessarily horizontal) bench (Li et al., 2011; Zoppi et al., 2011). The proposed system works in the following way. The object (a thin sheet workpiece, a panel) is introduced into the work-cell manually. Static clamps fix the workpiece initially and locate it accurately, except for sagging due to gravity. The supporting robots move to the vicinity of the place of machining to rigidly support the workpiece so that the CNC machine can perform its operation in that location. The robots relocate themselves over a bench, which contains docking elements. The docking elements form a mesh of equilateral triangles. The base of the robot, when supporting the machined panel, is docked to three adjacent docking elements forming a triangle. During transfer to another location it detaches from two of the docking elements and rotates itself around the one that remains attached to the bench. Once the robot is again securely locked to the bench the PKM lifts the supporting head to the prescribed location, thus providing support to the machined metal sheets. Initially the head is soft, but once it has reached the prescribed location it is solidified and vacuum is applied to suck the sheet to the head, thus holding it firmly. The panels are either subjected to drilling or milling. 2.2. The planner

87

endings called vertices. One can expect the length of a line segment to be equal to or larger than the side length of the head. A contour point is a true vertex if it satisfies the following conditions: (1) it marks a line segment ending, i.e. a point at which a rapid change of the contour's curvature appears, measured within a local neighbourhood; (2) two consecutive vertices should be connected by a sufficiently long line segment (this condition is needed to avoid contour segments with lengths less than a head's side length – if two line endings points are at close distance to each other then only one of them can be a vertex point). Contour corners are not considered to be vertices (i.e., endpoints of segments) if their angles are larger than 120o or they are at a small distance (as compared to the head-side length) to a “dominating” corner (i.e. with a lower vertex-type index). Hence, some more corners are filtered from the vertices list in order to avoid small-size segments. This leads to the classification of segments into: type 1 (a single-line segment), type 2 (a manyline convex segment) and type 3 (a many-line concave segment). 2.4. The path planner The path planner is the core of the whole planner. It takes the form of a hierarchic CSP search process. The path planner is composed of the Main control module and three path planning modules (CSP 1, CSP 2, CSP 3), which are called: Head-CSP, Base-CSP and PKM-CSP. The Main control module exercises overall control over the path- and time-plan creation for current environment parameter setting. In particular its goal is to react of failures of the plan creation process. A failure means that at some contour segment no on-line continuation of the fixture plan will be possible. Then the machining process must be split into several parts or the control asks for environment parameter change. In first case, the Head-CSP module is called again for next subpart of the contour, starting at the ‘failed’ vertex. The modules Head-CSP, Base-CSP and PKM-CSP are layers of a hierarchic CSP process. By applying an incremental state-space search with backtracking, these modules create head paths, base paths, and PKM paths, respectively.

The primary goal of the planner is to generate the path plan and the time-related execution plan for mobile fixtures (Fig. 2). The supporting agents must guarantee stable support at the region of the workpiece being currently machined. The required support stability for a given machining process is achieved when a set of constraints on the relative location of the tool and the supporting heads is satisfied. Moreover, for each agent, the supporting head can move continuously but must remain within the workspace of the PKM, while the mobile bases can only make discrete displacement steps between a finite set of locations, as determined by the docking and locomotion subsystems. Furthermore, motion speed must match the motor constraints.

2.5. Time plan

2.3. Workpiece modelling

3.1. CSP definition

The goal of workpiece modelling is to analyse the path of the tool on the workpiece and to decompose it into segments. For example, before the path planning for a milling process will start, the milling contour is divided into line segments separated by vertices. In practice, an equilateral triangular head is used with circa 70 mm sides. In general, a contour's segment is a polyline with many intermediate line endings (corners), and two segment

The discrete CSP (constraint satisfaction problem) is described as follows:

After a feasible path plan is found the time planner module defines a time schedule for actions contained in the path plan. The actions of agents are performed sequentially according to a time plan. The state of every part of every agent (a vector variable) contains, among others, two time points: the time point of latest possible action end to reach current position (state) and the time point of earliest possible action start to move to next position (state).

3. The hierarchic CSP search

 A complete state s A S is given as s ¼ ðx1 : d1 ; x2 : d2 ; …; xn : dn Þ, where the xi ; ði ¼ 1; …; nÞ, are variables and the di A Di ; ði ¼ 1; …; nÞ are values from some (finite) domains Di ; i ¼ 1; …; n, that are assigned to variables.

88

W. Kasprzak et al. / Engineering Applications of Artificial Intelligence 34 (2014) 85–98

Fig. 2. The overall planner structure and its application environment (the task, the object and mobile robots).

 There is an action set A, where each action, ak A A, means a 

transition between two states: ak : si -sj . A graph of constraints, CðxÞ, specifying allowed combinations of values for subsets of the variable set.

To solve a discrete CSP means to search for assignments to a finite set of variables: fXi ¼ di ji ¼ 1; …; Ng, where Xi and di A Di are variables and assigned values, respectively. Typically, a solution to a problem represented as a CSP is found by a (partly applicationindependent) depth-first search with backtracking in the decision tree of alternative assignments to given problem variables. A solution to the CSP is every complete assignment (i.e. a path from root node to terminal node of length N) that satisfies the set of constraints (Fig. 3). A complete state s ¼ ðx1 : d1 ; x2 : d2 ; …; xn : dn Þ, is a goal state if it satisfies all the constraints, i.e. Cðd1 ; d2 ; …; dn Þ ¼ True. With such a model of the problem an application-independent re-usable search algorithm can be designed. Then, it is sufficient to fit the search-based control with some agent-dependent data and functions – related to singlevariable assignments and constraints – to design a complete solution algorithm. 3.2. Incremental search for CSP This is a tree search problem in which every solution appears at depth n of the search tree, where n is the number of discrete variables (or assignments). Typically a strategy of depth-first search with backtracking is applied. In this strategy the search operates on incomplete states, i.e. partial states are defined by the values already assigned to variables. Specific features of this strategy are:

 Initial state is a state with the empty assignment to each variable.

 A state expansion means to generate possible successor states

  

of current state s by assigning a value to an unassigned variable in s. The application-dependent subroutine that returns the set of competitive expansions will be called as NextNodes(). The consistency test: check that the constraint set is not violated by existing assignments. This will be implemented by an application-dependent subroutine ConsistencyTest(). The backtrack step: reverse the last action and try another action if no legal assignments of current state exists or no goal state can be reached from this state. The goal test: the assignments in current state must be complete and must satisfy the constraint set. This will be implemented by an application-dependent subroutine StopTest().

3.3. A partial CSP search In our approach the CSP search not necessarily has to return a success, i.e. a complete solution. It is the case of a workpiece being too complex to be machined without a static re-fixturing. Then, our CSP search should deliver a partial plan. Thus one has to modify a typical incremental search for CSP in order to track the current plan and collect partial solutions as well. Observe the strategy defined in Tables 1 and 2. The recursive subfunction RecursiveBacktrackPartial stores the current partial plan in a collection called solutions. In case of success (complete solution found) this collection will contain the only complete solution, but in case of failure there will be alternative (most largest and unique) partial solutions returned (consisting of a sequence of variable-to-value assignments). In the main function CSPSearchPartial the best solution (eventually a partial one) is selected and thus it provides at least a partial plan (if not a complete one) for the workpiece contour. 3.4. A complete CSP search The partial plan is allowed only for the head path plan. In our hierarchic CSP approach the consistency check for a single assignment of a head variable includes an immediate call to CSP search for a corresponding base plan. Remember that the CSP variable for heads corresponds to an array of head positions allocated for a single contour segment. The verification of this (array-like) assignment consists of a run of CSP search for bases and another complete run of CSP search for the PKM-s. The eventually detected plans for bases and PKM-s are limited in range to a single contour segment, the currently assigned CSP-head variable. As these two CSP searches play a verification role, there should be complete solutions obtained for these limited CSP problems. A typical incremental search for complete CSP is given in Tables 3 and 4. Here the recursive subfunction RecursiveBacktrack has only to store current partial plan and there is no need to select among many partial solutions in the main function CSPSearch. 3.5. Computational complexity Computational complexity expressed in terms of the number of expanded search tree nodes is comparable to the complexity of a depth-limited search (Russel and Norvig, 2002). (There is a flexible limit value, since the limitation is due to the backtracking step and a particular execution depends on whether the constraints are satisfied or not.) The expected computational complexity is determined by the number of visited search tree nodes and the number of constraints checked during the search process.

W. Kasprzak et al. / Engineering Applications of Artificial Intelligence 34 (2014) 85–98

89

Fig. 3. Illustration of the backtracking CSP search (for heads). A state (tree node) corresponds to a set of head assignments to the search variables. Alternative locations of heads for a single contour segment constitute alternative assignments to a variable. A depth-first tree search strategy is applied, while backtracking steps appear if the assignments to current variable set ðX 1 ; X 2 ; …; X n Þ violate the constraints.

Table 1 The partial CSP-search with backtracking strategy.

In the proposed application case these parameters have the following meaning:

 The number of variables is equal to the number of segments in 

The number of search tree nodes depends on two parameters of a single CSP search: N, the number of variables and B, the average branching factor of the tree. For a complete CSP search the expected number of visited nodes is 1 N=2 N NodesðB; NÞ ¼ ∑ ðBi Þ þ ; 2i¼1 2

ð1Þ

i.e. the tree is expanded to half of the depth and width before a solution path of length N is found. For a partial CSP search the expected number of visited nodes is 3 N=2 N NodesP ðB; NÞ ¼ ∑ ðBi Þ þ ; 4i¼1 4

the workpiece contour (in CSP 1) or it is related to the number of heads found in CSP 1 (variables in CSP 2 and CSP 3). The branching factors depend on the discrete resolution of the domains - the possible positions and orientations of heads (CSP 1 – alternatives are limited to several hundred cases), the possible positions and orientations of the bases (CSP 2 – alternatives are limited to several locations and orientations), and the possible positions of the PKM for a base-head pair (CSP 3 – several alternatives of every action of the PKM).

Besides the number of search tree nodes the processing time of the planner is also influenced by the number of constraints defined for the variable set. To make the times of node visitation (and expansion) comparable with times required to calculate predicates for these constraints, let us model them as follows:

 The visitation (expansion) of one search tree node needs in average one abstract time unit.

ð2Þ

 The average time for checking all the constraints related to one

i.e. the tree is alternatively expanded to half of the depth and to a full width, when no complete solution is found, or it is expanded to half of the depth and width, when a complete solution exists.

variable is modelled by a parameter C. Hence, if the assignment for given variable corresponds to a node at search tree level L, then the time needed for checking new constraints is in average equal to ðC  L=NÞ.

90

W. Kasprzak et al. / Engineering Applications of Artificial Intelligence 34 (2014) 85–98

Table 2 The recursive subfunction of partial CSP-search.

Table 3 The complete CSP search.

Under the above assumptions, the expected computational complexity of a complete CSP search is given as 


 1 C C NC þ B2 1 þ 2 þ ⋯ þBN=2 1 þ OðB; N; CÞ ¼ B 1 þ 2 N N 2N
 N L þ ∑ 1þC N L ¼ N=2 þ 1
 1 C OðB; N; CÞ ¼ BN=2 1 þ þ fresg: 2 2

ð3Þ

A comparable complexity of a partial CSP search is 


 3 C C NC OP ðB; N; CÞ ¼ B 1 þ þ B2 1 þ 2 þ⋯ þ BN=2 1 þ 4 N N 2N
 N 1 L þ ∑ 1þC 2 L ¼ N=2 þ 1 N
 3 C þ fresP g: OP ðB; N; CÞ ¼ BN=2 1 þ 4 2

Thus, the expected computational complexity of both CSP algorithms is polynomial with respect to the branching factor, exponential – with respect to the number of variables and linear – with respect to the number of constraints per variable. In the hierarchic CSP approach the first (upper) layer CSP 1 is assumed to be a partial CSP, while the lower layers (CSP 2,…,CSP n) are complete CSPs. For simplicity, let us estimate the computational complexity of the triple-CSP case, as given in our application. The particular parameters are: ðB1 ; N 1 ; C 1 Þ; ðB2 ; N 2 ; C 2 Þ; ðB3 ; N3 ; C 3 Þ. The inherent assumption of the hierarchic CSP is that N1 r N 2 r N3 , i.e. there is a non-decreasing number of variables in CSP 1, CSP 2 and CSP 3 when moving from top to bottom of the hierarchy. Thus, after each next assignment to a variable in CSP 1, a “local” CSP 2 search is called by the ConsistencyTest() (a “local search” means that it will assign values to those variables in CSP 2 only, that are related to variables in CSP 1, already assigned by the upper-level CSP search). In turn, a single variable assignment in CSP-2 search is “verified” by a call to a “local” CSP-3 search. When all CSPs are solved by a single CSP, a nonhomogeneous search process is needed (with different structures of variables and constraints). The computational complexity of such a single partial CSP depends on:

 The total number of variables, which is the sum of the variables of individual problems: N s ¼ N1 þ N 2 þ N 3 .

 The average branching factor, which is a weighted average of branching factors: Bs ¼ 1=N s ∑i ðN i  Bi Þ.

ð4Þ

 The average number of constraints that are checked with a new assignment: C s ¼ 1=W∑i ðNi  Bi  C i Þ, where W ¼ ∑i ðNi  Bi Þ.

W. Kasprzak et al. / Engineering Applications of Artificial Intelligence 34 (2014) 85–98

91

Table 4 The recursive subfunction of complete CSP-search.

Table 5 Expected computational complexity of a single nonhomogeneous CSP search and the proposed hierarchic CSP search.

For a single partial CSP search the expected complexity is Os ðBs ; N s ; C s Þ 


 3 Cs Cs Ns C s ¼ Bs 1 þ þ B2s 1 þ 2 þ ⋯ þ BsNs =2 1 þ 4 Ns Ns 2 Ns
 Ns 1 L ∑ 1 þC s þ 2 L ¼ ðNs =2Þ þ 1 Ns
 3 Cs þ fress g: Os ðBs ; N s ; C s Þ ¼ BsNs =2 1 þ 4 2

Parameters B1 ; B2 ; B3

ð5Þ

The complexity of the hierarchic triple-CSP can be estimated as follows: 3 N1 =2 N1 Nodes1 ¼ ∑ ðBi1 Þ þ 4i¼1 4

ð6Þ

" Nodes2 ¼ Nodes1  0:5 

0:5N 2 =N1

∑

i¼1

ðBi2 Þ þ

N2 2

# ð7Þ

 OH ðBi ; Ni ; C i i ¼ 1; 2; 3Þ "
#
 N1 3 N1 =2 i C1 1 L ∑ 1 þ C1  ¼  ∑ B1 1 þ i  þ  4 i¼1 2 L ¼ ðN1 =2Þ þ 1 N1 N1 "
#
 N 2 =2 N2 C2 L þNodes1  0:5  ∑ Bi2 n 1 þ i  1 þ C2 þ ∑ N2 N2 L ¼ ðN 2 =2Þ þ 1 i¼1 " þNodes2  0:5 

N 3 =2

∑ Bi3 n 1 þ i 

i¼1

OH ðBi ; Ni ; C i ji ¼ 1; 2; 3Þ ¼




C3 N3

# þ

N3

∑

L ¼ ðN 3 =2Þ þ 1

3 N =2 N =2N N =2N  B 1  B2 2 1  B3 3 2 16 1


1 þ C3

L N3



ð8Þ

Complexity N1 ; N2 ; N3

C1 ; C2 ; C3

Single CSP

Hierarchic CSP

30, 3, 3

10, 10, 50

30, 30, 150

5:59  1030

8:01  1011

30, 10, 3

10, 10, 50

30, 30, 150

5:98  1032

1:07  1012

30, 10, 10

10, 10, 50

30, 30, 150

2:65  10

40

2:44  1012

30, 3, 3

100, 100, 500

300, 300, 1500

1:33  10295

2:11  1081

3, 3, 3

100, 100, 500

300, 300, 1500

169

3:06  1031

6:40  10

  1  1 þ ðC1 þ C2 þC 3 Þ  fresH g: 2

ð9Þ

Table 5 presents some expected complexity numbers for different parameter settings. The comparison of results for a single CSP search, that integrates three sets of variables, and the proposed hierarchic CSP search, clearly documents the efficiency advantage of the second approach.

4. Hierarchic CSP search-based path planning 4.1. CSP variables and discrete domains The path plan contains three lists of states for the subcomponents of each agent, ½hi ; ½bi ; ½pj , containing the consecutive locations of heads, bases, and PKMs, respectively. Let us limit the illustration to two agents only and to a one-to-one correspondence of head-to-base states. Then the first agent's head and base states are indexed by odd numbers, while the second agent's states – by even numbers. There are several states (for example 5) of the PKM corresponding to a pair of head-base states. Hence, the index “j” is

92

W. Kasprzak et al. / Engineering Applications of Artificial Intelligence 34 (2014) 85–98

not directly related to the index “i”. A transition between two consecutive states of one agent is specified together by: 1. a head transition hi -hi þ 2 – there is an appropriate rotation around the local YH axis performed, while the main movement of head is resulting from a sequence of actions of the base and the PKM; 2. a base transition bi -bi þ 2 – there is an appropriate rotation of the mobile base performed by 01, 7601 or 71201 (this action may be empty when the same base state is needed for consecutive head states); 3. a sequence of PKM states pj -pj þ 1 -⋯-pj þ 5 , where the state pj corresponds to ðhi ; bi Þ and state pj þ 5 to ðhi þ 2 ; bi þ 2 Þ – the transition between 2 consecutive PKM states is defined in the object space. In general, the state variables for the heads, the mobile bases and the PKMs are real-valued vectors. This would lead to an infinite number of possible positions and configurations of the agent. But a discrete CSP can efficiently handle only a finite state space. Therefore, the continuous domain of each variable needs to be approximated by a finite set of discrete values taken with sufficient resolution. For example, if a parameter representing a rotation angle can take values from a continuous interval, [ 301, 301], then one might be satisfied with an approximation with resolution of 11 by a set of 61 discrete angle values: f  30;  29; …; 0; …29; 30g. The resolution of relative discrete locations for a single head can be set to: n  n, where n ¼ 1 þ ð2Dmax =Dmin Þ (for the definition of Dmax ; Dmin see next subsection). Even with such a necessary digitalisation, the number of domain values can be very high. Fortunately, for most of our CSP variables there exist local optimisation criteria, that allow to order the domain values starting with the most promising ones. For example, looking for a relative orientation of the head triangle along a workpiece contour the parallel-to-contour orientation (i.e. with angle value 01) is selected as the best one. 4.2. Head path planning by partial CSP search This planner module is designed as a partial CSP search with matrix-like variables. Each variable corresponds to a sequence of heads for a single segment of the workpiece contour. Thus, in a single assignment step a sequence of head positions is assigned at once. The Head-CSP module is executed by a call from the Main control module. This occurs once for the entire contour, or one

time per part of the contour if there are break points and multiple sub-plans are generated. A CSP search requires application dependent data and functions to be supplied. In the case of Head-CSP, a set of head variable constraints and a function generating alternative head variable assignments, are needed:

 Head-workpiece constraints: A labelled graph and a program code for the meaning of predicates.

 Next-Head: Application-dependent program code for the generation of alternative head variable assignments, which correspond to successor nodes of the search tree in a given state of the CSP-search process. In a single extension of the search tree by Head-CSP head states are assigned to one contour segment. For efficiency reasons, before making the next extension, it is useful to check whether suitable corresponding base- and PKM-paths can be found. Currently assigned head states are passed to Base-CSP, which eventually returns Failure, or, in case of success, a partial base- and PKM-plan corresponding to the current contour segment. In case of failure, the head planner module performs a backtracking step in order to revise the last segment assignment. 4.2.1. Head constraints Due to the inherent character of a milling or holing process (during which part of the original metal sheet is cut off) the workpiece can be supported only from one side of the contour. In the final path plan, consecutive head states along the workpiece contour are numbered h1 ; h2 ; h3 ; …, where odd and even indices denote head locations of the first and second agents (head 1 and head 2), respectively (Fig. 4). Obviously, the assigned values should satisfy the geometric constraints of not having conflicts with other heads or with the workpiece contour. Please note, that a variable Xi in Head-CSP search is defined by a sequence of heads allocated for given contour segment (with index “i), i.e. Xi ¼ ½hi;1 ; hi;2 ; …; hi;N . The constraints are defined between two consecutive head states within of a single variable Xi or between two consecutive variables Xi and Xi þ 1 . The FEM analysis delivered sets of feasible support regions for a single head or for two heads. Then it is converted into the form of geometric constraints – requirements posed onto distances and orientations between heads and machined workpiece contour. Support quality and stability depends on the head-edge distance to the tool. After locating two supporting heads along the machined contour their joined support for every point of the contour can be computed by numeric integration of FEM data over surface patches. The support force depends on the location of

Fig. 4. Illustration of the basic sequence of head positions: (a) only head 1 supports the workpiece, while head 2 relocates, (b) both head 1 and head 2 support the workpiece, and (c) only head 2 supports, while head 1 relocates to next position.

W. Kasprzak et al. / Engineering Applications of Artificial Intelligence 34 (2014) 85–98

heads relative to the contour (distances d1 ðpÞ; d2 ðpÞ) and relative to each other (distance dh). Assuming a required minimum force threshold one can determine the largest allowed distance between contour line and head (Dmax) and the largest allowed distance between two heads (Dh), i.e. maximum distances for which the force threshold is still satisfied. The test of constraint Dh also includes an obvious check whether the two heads do not intersect. A constraint Dmin is added for machining safety reason. It represents the minimum allowed distance between a head and a contour. 4.2.2. Alternative head assignments For every CSP search it is an essential to properly order the alternative assignments generated for one variable. For the HeadCSP this means to find the “best” number of heads (i.e. the lowest acceptable number) and their “best” positions (i.e. an interpolation between two terminal head positions for given segment) (Szynkiewicz et al., 2010). The head variable assignment strategy depends on the vertex and the segment types. The head planning step starts with an initial line segment having a start vertex, preferably of Type 0 (the attached angle is below 601). After having located the heads at the end-vertices of a given line segment, a sequence of intermediate head locations along this line is generated. Note that for the second and subsequent segments the start vertex has already been assigned a head location, namely the one assigned for the same vertex for the preceding segment. Depending on the segment length between the two heads at the endpoints, an appropriate number of intermediate head locations is used. If exactly N head-side lengths fit into the free distance, a standard in-line allocation is selected. Small differences are compensated by adding small intervals between consecutive heads. But when N heads are too much, and N  1 insufficient, for the given distance, a “shifted-fit” strategy is selected b): oddnumbered heads are located at a distance of Dmin from the contour line, while even-numbered heads are offset at Dmax (or vice versa). In this way, N heads can be allocated along a larger distance. Many other allocation alternatives are possible, as different distances from the contour line can be selected (in the range from Dmin to Dmax), many distances between consecutive heads (from 0 to Dh), as well as rotated heads are possible. 4.2.3. Regularity conditions The path planner can return a feasible head path if the workpiece contour is regular, i.e., if it satisfies these properties: 1. Line regularity: For each segment, at least one head can be placed between the adjoining vertices. 2. Area regularity: The inner area bordering three consecutive edges of a contour is sufficiently large to include two consecutive heads.

93

base state corresponding to an already specified single head state needs to be assigned. From previous module the Base-CSP receives a sequence of head states, given in the path plan related to a single segment of the workpiece contour. Recall that consecutive segments share their vertices, i.e. the last head and base position for one segment is at the same time the first position for the next segment. Again a graph of constraints for these variables, as well as a function generating new base variable assignments, must be supplied. After the base path plan is generated for the current segment the next module, the PKM-CSP, is called. A PKM path plan will be generated, corresponding to the existing head and base plans. In opposite direction, the notification about success or failure is returned to the Head-CSP. In case of success a path plan is returned with a sequence of base and PKM states, that are consistent with the current head plan. 4.3.1. Constraints for Base-CSP A base variable assignment must satisfy the given base constraints (Fig. 5). First, there is a collision avoidance constraint defined for the two agents. An agent's base is supposed to move from its current state, X i  1 , to the next state, X i þ 1 . Obviously a collision with the other agent's base and head, (bi ; hi ), has to be avoided. This is checked by the constraint: No_collision ðbi  1 ; bi þ 1 ; bi ; hi Þ. There is also a binary constraint defined between the base state assigned to variable Xk and its corresponding head state: In_workspaceðbk ; hk Þ; k ¼ i  1; iþ 1. While performing a complete agent movement most of the time is spent to move its base. All base transitions must contain a single unlock–lock sequence (one rotation only around some pin). This is represented by the constraint: Single_stepðbi  1 ; bi þ 1 Þ. 4.3.2. Alternative base assignments The domain of base locations is determined by the grid of docking places on the bench. The locally optimal strategy for base assignments, when head positions are already given, is summarised as follows :

 The head position is projected onto the bench plane and so is 



the inversed workspace envelope for the given elevation of the head. Try to minimise the number of base movements. If possible, find an overlapping region for the projected inverse workspace of two consecutive heads of the same agent. This is achieved by searching for candidate base centres within a rectangular boundary induced by the two heads. The obtained common base-centre candidates are next ordered by the number of elementary locomotion steps needed to

These are necessary properties – required by the applied head allocation strategy. A single segment need to be supported by at least one head position (causing line regularity) and a single head can have up to two “active” sides (this explains the area regularity). In general there is no guarantee that a feasible head plan will be found for regular contours. 4.3. Base path plan The goal of this module is to find an appropriate base path for a given head path (as related to one contour segment). The solution is again seen as a CSP search. To each Base-CSP variable a single

Fig. 5. Graph of constraints for the Base-CSP. A single CSP variable Xi consists of a mobile base state bi related to the already fixed head state hi.

94



W. Kasprzak et al. / Engineering Applications of Artificial Intelligence 34 (2014) 85–98

attain each from the current location of the corresponding agent. In case of equality, positions closer to the line connecting the two head position projections are preferred. If no such common base centre (serving the two head positions) exists, the next base location corresponds to one head only. It is determined by a single transition into a position within the inverse workspace at the next head location and in the direction of the second to next head.

As a result of the above preference strategy one obtains base plans with a minimum of base locomotion actions. Typically two or three head locations correspond to a single base location. The transition between two consecutive positions of a mobile base can be decomposed into five steps (Fig. 6). The minimisation of the number and amount of necessary rotations of mobile bases is the most crucial requirement for a feasible time plane. Due to its heavy weight, the mobile base determines in practice the action speed of the entire robot.

4.4. PKM path plan This module is called by the Base-CSP module and it receives as input a partial path plan with corresponding base and head locations for the workpiece segments, considered so far. The PKM-CSP returns a failure notification or a partial PKM plan, corresponding to the input data. 4.4.1. Basic sequence of PKM states For a given contour segment, the module generates a path of PKM configurations using the obtained paths of heads and bases. For a pair (predecessor–successor) of head and base states, and a given predecessor PKM configuration, five consecutive agent states with up to four PKM different postures are generated. Let the successor state is numbered N ¼5 - then the transitions are (Fig. 7):

 Transition to state 1: Retracting the head (away from the workpiece surface) in order to avoid collision with the part.

Fig. 6. Illustration of the basic mobile base actions: (a) and (b) unclamp and lift the two legs (pos. 1), (c) and (d) rotate the base by multiples of 60 degrees around the third (still clamped) leg (pos. 2), (e) lower and clamp the two “free” legs (pos. 3).

W. Kasprzak et al. / Engineering Applications of Artificial Intelligence 34 (2014) 85–98

 Transition to state 2: Moving the retracted head back to a   

parking position above the base, to avoid collision with the other agent. Transition to state 3: A displacement of the base follows. DOFs 1–6 remain unchanged. The PKM frame is rotated and the β7 orientation angle changes to the goal value. Transition to state 4: Moving the PKM so that the head is only a normal approach away from its desired support location. Transition to state 5: The final approach of the head is executed and the required state is reached.

Solving the inverse kinematics of the PKM, provides most of the PKM state variable assignments and allows to check if the desired position of the head can be reached with the current position of the PKM base. 4.4.2. Constraints for PKM-CSP The third CSP search (PKM-CSP) is called for every pair of corresponding base-head states of the current agent, ½ðbi  1 ; hi  1 Þ; ðbi þ 1 ; hi þ 1 Þ, as assigned to the CSP variables in Base-CSP and Head-CSP, given the knowledge of the other agent's base and head state ðbi ; hi Þ (Fig. 8). Let us observe that an agent state, S ¼ ½h; b; p, is an aggregation of states of its three parts. There are three types of PKM constraints:

 Inverse_kinematicsðhi þ 1;k ; pi þ 1;k Þ: The head state h and the



required PKM state p must satisfy the inverse kinematics relation of the agent, i.e. a valid configuration of the PKM must correspond to them. No_collisionðSi ; Si þ 1;k  1 ; Si þ 1;k Þ: A collision check during the transition of the current agent from state Si þ 1;k  1 to state Si þ 1;k with the currently fixed other agent (in state Si);

95

 Nextðpi þ 1;k  1 ; pi þ 1;k Þ: The PKM states must be ordered correctly.

5. Experiments The implementation of the path planner, described in previous sections, has been tested in real-life conditions. Various path plans for drilling and milling processes have been generated using the triple-CSP approach. The exact computation time of the planner is not a crucial factor as the plan is computed in an off-line manner. It turned out, that when the problem is not over-constrained a feasible solution for a typical machining process can usually be found in less than one minute. An over-constrained problem leads in practice to several partial solutions, instead of a single complete one. In the experiments the planner needed up to 30 min to accomplish this task. A complete task plan consists of four parts, i.e. the path plans for heads, bases and PKMs, as well as the time plan for all positions and actions in the path plans. Let us consider the hole drilling or milling process along the outer contour of the first workpiece. In the experiment the tool speed along distances between holes is assumed to be 5 mm/s, while the total time for drilling a single hole is 3 s. The plan contains also a reference time schedule for visiting contour corners (in milling) and holes (in drilling), that allows the agent's controller (Zieliński et al., 2011) to synchronise the plan execution with the CNC machine and to react to unexpected events or time delays. In the following, it is demonstrated how different agent-related constraints and parameters influence the path plan.

Fig. 7. Illustration of the basic PKM relocation sequence: (a) lower the head from supporting position “0” to “free” position “1”, (b) move the head back to reach a position “2” over the base, (c) rotate the PKM relative to base (a base relocation is eventually performed also) to reach the new direction “3” of next supporting head location, (d) move the head out of the base to reach a position “4” below the next supporting head position, and (e) complete the relocation by lifting the head to the next supporting position “5”.

96

W. Kasprzak et al. / Engineering Applications of Artificial Intelligence 34 (2014) 85–98

5.1. Workpiece modelling parameters

5.2. Bench location parameters

A circle needs first to be approximated by a regular polygon. Our head allocation strategy requires that every workpiece's line segment is at least equal or longer than the half of the head side length. This may be relaxed for circular and convex contours. The circle approximation is performed during the workpiece modelling step. In given example, 7 holes need to be drilled around a circle. Let us first approximate the circle by a 7-sided (open) polyline, where the lines are of tangential directions to the circle at the drilling points. The edge lengths are similar to a head side length and the path plan consists of 7 head states. The second approximation uses a 15-sided closed polygon and the plan needs 8 head states (Fig. 9). In both cases the workpiece modelling module creates a contour which consists of a single segment (i.e. a single polyline) only.

Next type of environment parameters represents the relocation of workpiece in the horizontal or vertical plane w.r.t. the bench. First, one can change the height of workpiece location over the bench (a vertical shift). This modification is needed when the workpiece's height location is outside of the scope of the PKM. In order to get the same effect, dually the agent's height could be changed. At second, the workpiece can be shifted in the horizontal plane w.r.t. the bench (Fig. 10). This modification is needed when no base plan is found that corresponds to given head plan or when the base movements need to be minimised (for time efficiency). To get the same effect, dually the head arm could be redesigned (enlarged).

5.3. Agent dependent parameters In order to change agent-dependent parameters one need to redesign the entire agent or at least one of its components (e.g. the head). First, when the contour contains short line segments and a complete head plan can not be generated, it may be necessary to apply a head of smaller size. At second, when the workpiece is out of reach of the head, it may be necessary to change the length of the arm that connects the head with the wrist of the PKM; At third, when some head state has no base state, it may be necessary to change (increase) the PKM workpiece radius w.r.t. the mobile base's longitudinal axis (Fig. 11).

Fig. 8. Graph of constraints for the PKM-CSP. A single CSP variable X ¼ Si;k represents the state of the entire agent. It consists of a PKM state P i;k related to the already fixed mobile base state bi;k and head state hi;k .

Fig. 9. Different head plans for the hole drilling around a circle, approximated by a 7- (left drawing) or 15-sided-polygon (right drawing).

6. Conclusions This paper discusses the novel use of artificial intelligence tools for the task and motion planning of a flexible fixturing system with multiple cooperating mobile robotic agents. The introduced new approach, which views robot task and motion planning as a constraint satisfaction problem (CSP), and the proposed solution in the form of hierarchical search algorithms, makes this work potentially applicable to other automation problems. The considered application case, a self-reconfigurable fixture system, is primarily targeted at the aerospace industry. However it can also be applied in the automotive, shipbuilding and other industries, where large thin-walled parts are machined. In order to change the application one needs to supply the search algorithms with appropriate agent-dependent and process-dependent data and to implement functions that are related to the specific search domain and constraints.

Fig. 10. A small shift of the workpiece in the X W Z W plane w.r.t. the bench can change the path plan, i.e. decrease the number of different base positions.

W. Kasprzak et al. / Engineering Applications of Artificial Intelligence 34 (2014) 85–98

97

of every agent is decomposed into subsets according to part types of agents (e.g. a head, a base and a PKM). Thus, the multi-agent system is not distributed horizontally (into CSPs that can eventually be solved in parallel) but is decomposed vertically into different CSPs, where the integration of a parent CSP with its child CSP is performed via the constraint consistency test of the parent search. To the best of our knowledge the use of such hierarchical CSP searches is a novel technique in the path planning of mobile robots. The partial CSP is commonly assumed to be an ordered sequence of relaxed CSPs, inherited from a single basic CSP by cancelling particular constraints from the graph of constraints of the basic CSP (Freuder and Wallace, 1992). The solution to a partial CSP is a complete solution to the nearest relaxed CSP. In our approach, relaxed CSPs are not made explicitly, while the optimal partial solution is not expressed in terms of minimising a distance to a complete graph of constraints but in terms of maximising the number of successfully assigned variables.

Acknowledgements This work was supported by the European Union Framework Program Theme [NMP-2007-3.2-1] within the Project SwarmItFIX, Grant No. FP7-214678.

References

Fig. 11. The influence of the PKM workspace radius onto a path plan for heads and bases: (a) the radius (225 mm) is to small – the base plan fails at the third segment already, (b) the radius (250 mm) is still to small – the base plan fails at the fourth segment, and (c) the radius (300 mm) is sufficiently large – a complete head and base path plan for the entire contour is created.

The core of the system is the path planner that follows the methodology of constraint satisfaction problems (CSP). In the presented application, the path planning problem is solved for the three parts of each agent (head, mobile base and PKM) in terms of three CSPs. For efficiency reasons, a hierarchy of three incremental CSP searches is proposed. This structure allows to verify single assignments within the head CSP, performed for the head plan, by assignments within the base CSP, and these in turn are verified by assignments within the PKM CSP. Methods referred to as distributed CSP (Yokoo et al., 1998; Yokoo and Hirayama, 2000), hierarchic CSP (Papadias et al., 1999), partial CSP (Freuder and Wallace, 1992; Hirayama and Yokoo, 1997) and hierarchic partial CSP (Hirayama and Yokoo, 2000) have been used in the past, but they differ from our approach. A distributed CSP, as defined in Yokoo et al. (1998) or Yokoo and Hirayama (2000), is not considered in this paper, as the actions of agents have to be performed synchronously in time and typically in an interleaved fashion – one after the other. The hierarchical CSP has been understood as the decomposition of a large domain of values into a resolution hierarchy (e.g. specified by R-trees that accompany the CSP) (Papadias et al., 1999) or preference (importance) levels of particular constraints (Hirayama and Yokoo, 2000). In our approach, the set of variables

Avvenente, R., Khan, M., Li, X., Zoppi, M., Zlatanov, D., Molfino, R., 2010. Development and analysis of a shape-conformable supporting head for a selfreconfigurable intelligent swarm fixture system. In: ISR/ROBOTIK 2010 Proceedings. Munich, Germany, pp. 792–799. Bi, Z., Zhang, W., 2001. Flexible fixture design and automation: review, issues and future directions. Int. J. Prod. Res. 39 (13), 2867–2894. Boyle, I., Rong, Y., Brown, D., 2011. A review and analysis of current computer-aided fixture design approaches. Robot. Comput. Integr. Manuf. 27 (1), 1–12. Chakrabarti, P.P., et al., 1989. Heuristic search in restricted memory. Artif. Intell. 41, 197–221. Choset, H., Lynch, K., Hutchinson, S., Kantor, G., Burgard, W., Kavraki, L., Thrun, S., 2005. Principles of Robot Motion: Theory, Algorithms, and Implementations. MIT Press, Cambridge, MA, USA. de Leonardo Girard, L.M., Zoppi, M., Zlatanov, D., Xiong, L., Molfino, R.M., 2013. SwarmItFIX: a multi-robot-based reconfigurable fixture. Ind. Robot-Int. J. 40 (4), 320–328. Freuder, E.C., Wallace, R.J., 1992. Partial constraint satisfaction. Artif. Intell. 58 (1–3), 21–70. Gonzalez-Rodriguez, A., 2011. Collision-free motion planning and scheduling. Robot. Comput. Integr. Manuf. 27 (3), 657–665. Hirayama, K., Yokoo, M., 1997. Distributed partial constraint satisfaction problem. In: Lecture Notes in Computer Science, vol. 1330. Springer-Verlag, pp. 222–236. Hirayama, K., Yokoo, M., 2000. An approach to over-constrained distributed constraint satisfaction problems: distributed hierarchical constraint satisfaction. In: Proceedings ICMAS 2000. ACM, New York, pp. 135–142. Kondrak, G., van Beek, P., 1997. A theoretical evaluation of selected backtracking algorithms. Artif. Intell. 21, 365–387. Korf, R.E., 1990. Real-time heuristic search. Artif. Intell. 42, 189–211. LaValle, S., 2006. Planning Algorithms. Cambridge University Press, Cambridge, UK. Leitao, P., Barbosa, J., Trentesaux, D., 2012. Bio-inspired multi-agent systems for reconfigurable manufacturing systems. Eng. Appl. Artif. Intell. 25 (5), 934–944. Li, X., Zoppi, M., Molfino, R., de Leonardo Girard, L.M., 2011. Design of mobile base for a self-reconfigurable intelligent swarm fixture system. In: Proceedings CLAWAR 2011. Paris, France, pp. 925–932. Molfino, R., 2011. Dispositivo di supporto con superficie di contatto conformabile e riconfigurabile. Italian Patent ITGE20100064 (A1). Neumann, K.-E., 2008. Structure Concept of exechon PKM. Technical Report 34, Exechon, Stockholm (2008) [cited 7.08.2011]. 〈http://exechonworld.com/docu ment/200804/article34.htm〉. Papadias, D., Kalnis, P., Mamoulis, N., 1999. Hierarchical constraint satisfaction in spatial databases. In: Proceedings of AAAI. Orlando, Florida, July 18–22, 1999. Pearl, J., 1984. Heuristic, Intelligent Search Strategies for Computer Problem Solving. Addison-Wesley, Reading, Mass. Russel, S., Norvig, P., 2002. Artificial Intelligence. A Modern Approach. Prentice Hall, Upper Saddle River, NJ. Salido, M.A., Giret, A., 2008. Feasible distributed CSP models for scheduling problems. Eng. Appl. Artif. Intell. 21 (5), 723–732.

98

W. Kasprzak et al. / Engineering Applications of Artificial Intelligence 34 (2014) 85–98

Salido, M.A., Garrido, A., Bartak, R., 2008. Introduction: special issue on constraint satisfaction techniques for planning and scheduling problems. Eng. Appl. Artif. Intell. 21 (5), 679–682. Szynkiewicz, W., Zielińska, T., Kasprzak, W., 2010. Robotized machining of big work pieces: localization of supporting heads. Front. Mech. Eng. China 5 (4), 357–369. Yokoo, M., Hirayama, K., 2000. Algorithms for distributed constraint satisfaction: a review. Auton. Agents Multi-Agent Syst. 3 (2), 198–212. Yokoo, M., Durfee, E.H., Ishida, T., Kuwabara, K., 1998. The distributed constraint satisfaction problem: formalization and algorithms. IEEE Trans. Knowl. Data Eng. 10 (5), 673–685.

Zieliński, C., Kornuta, T., Trojanek, P., Winiarski, T., Walecki, M., 2011. Specification of a robot-based reconfigurable fixture control system. Lecture Notes Control Inf. Sci. 422, 171–182. Zieliński, C., Kasprzak, W., Kornuta, T., Szynkiewicz, W., Trojanek, P., Walecki, M., Winiarski, T., Zielińska, T., 2013. Control and programming of a multi-robotbased reconfigurable fixture. Ind. Robot-Int. J. 40 (4), 329–336. Zoppi, M., Molfino, R., Zlatanov, D., 2011. Bench and method for the support and manufacturing of parts with complex geometry. European Patent WO2011 EP58992 20110531.