AN AUTOMATIC PROGRAMMING TOOL FOR ROBOTIC POLISHING TASKS∗ Jan Rosell
Jaume Gratac` os
Luis Basa˜ nez
Institut d’Organitzaci´ o i Control de Sistemes Industrials (UPC), Diagonal 647, 08028 Barcelona, SPAIN Phone: +34 (93) 4016653, Fax: +34 (93) 4016605 e-mails:
[email protected],
[email protected],
[email protected]
Abstract: Parts polishing is a repetitive task generally done in unhealthy conditions. It is therefore desirable that robots replace humans in performing these kind of tasks. Nevertheless, its programming is difficult, tedious and time-consumming. This paper presents a tool to automatically program a robot from a high level description of the polishing task. Given the specification of the polishing curves over the part, the location of the polishing bands where each operation must be performed, and a description of the cell, then a robot program to perform polishing trajectories in the optimum sequence is genered, the paths between trajectories being collision-free.
1
Introduction
The use of robots in industry gives rise to an increase in the productivity and in the quality of the products, while allows the performance of a vast range of tasks due to their flexibility. Nevertheless, the use of robots to automate some tasks involving sensors and motion planning strategies has been restrained mainly by the difficulty of their programming. Therefore, there is the need of systems able to program the robot motions from a high level description of the task. Some examples in this direction can be found in different robot application, as for example compliantmotion [6], assembly [5] and polishing tasks [2]. This paper presents a tool for the automatic programming of robotic polishing tasks from a CAD description of the part to be polished. It is assumed that the part is held by the robot gripper. The proposed approach can be easily extended to other similar tasks like cutting or material dispensing. ∗ This
work was partially supported by the CICYT project TAP96-0868.
2
Problem Analysis
Let us define: • Polishing curve: Curve over the surface of a part to be polished representing a strip that must be polished continuously. It is defined as an ordered set of reference frames over the surface of a part to be polished.The z-axis of each reference frame is normal to the surface and the x-axis points to the next reference frame. • Polishing station: Set of polishing locations which allow the same surface finishing. It is described by a set of reference frames over the polishing bands. • Trajectory: Set of ordered robot configurations, a configuration being defined by the joint variables. They can be either polishing trajectories, that allow to follow a polishing curve at a given polishing station, or linking trajectories, that allow the robot to connect two polishing trajectories through a collision-free path. • Polishing motion sequence: The minimum time sequence of trajectories which allows to follow all the polishing curves of a part. The aim of this project is to automatically synthetize the polishing motion sequence from the description of the polishing curves over a CAD model of the part to be polished. To achieve this objective, two problems must be solved: Optimization problem: Find the best feasible sequence of polishing trajectories for a given sequence of polishing curves. This must take into account that different trajectories can be used to follow each of the polishing curves, since: - Each polishing station is composed of several polishing locations. - The part is allowed to be grasped in different ways. - The polishing curves may be followed in either sense.
- If the polishing curves are closed curves, any of its configurations can be the initial one.
3
- The inverse kinematics has different solutions.
The robot program is synthesized in two steps. First the polishing collision-free trajectories for each polishing curve are obtained applying the robot inverse kinematics (the collision-free condition is verified using the validation tool presented in subsection 3.2), and the optimization problem is solved. Then the obstacle avoidance is tackled for the linking trajectories. The modules to perform these steps are described in the following subsections.
- The range of joints 4 and 6 could be greater than 360o , with the possibility of the range of joint 6 being unbounded. Path planning problem: Find collision-free linking trajectories through the polishing cell. The decription of the polishing cell is provided by a VRML file with the geometry of a set of convex solids representing the objects in the cell. The descriptions of the polishing curves over the CAD model of the part are obtained with the aid of an interactive graphic software. As a result, an ASCII file including information about the curves, the grasppings and the polishing stations is obtained: a) Each polishing curve is described by the following parameters: - Execution speed. - Polishing station where to be executed. - Allowed execution senses. - Sequence of reference frames located at points of the curve with z-axis normal to the surface and x-axis pointing to the next reference frame. - Force specification in the z-direction of each reference frame. b) The graspings are described by homogeneous transformations relating the reference frame of the part to the reference frame at the wrist of the robot. c) The polishing stations are described by a set of homogeneous transformations relating the reference frames of the polishing locations to the cell reference frame. The output files of the automatic programming system are the following: Execution file: A program that allows the execution of the task by the robot. The program (in the present case a V+ program for a St¨aubli RX90 robot) is a sequence of motions between robot configurations, defined as joint space motions for linking trajectories and as cartesian space motions for polishing trajectories, with force references to be used by an active compliant polishing station. Simulation file: A VRML file which contains the robot motions for the simulation of the task.
3.1
Program Synthesis
Graph optimization module
The optimization module finds the best feasible sequence of polishing trajectories. It initially considers that a linking trajectory is a linear path in joint space connecting the last and the first configurations of two consecutive polishing trajectories, i.e. it does not take into account possible collisions. The problem of searching the optimum sequence of trajectories can be represented as the problem of searching the path of minimum cost through an oriented graph (Figure 1), where: • Each node represent a feasible trajectory to perform a polishing curve (the nodes are grouped in columns representing the same polishing curve); and the nodes ni and nf represent, respectively, the initial and the final configurations. • The arcs represent linking trajectories. The cost of a trajectory represents the time needed for the execution of the corresponding motions. It is computed as follows. Let ∆θi be the angular motion of joint i for a given linking trajectory, and vimax its maximum angular velocity. The minimum time to perform the motion of joint i is ti = ∆θi /vimax . Then, the cost C of a trajectory is: C = ti | ti ≥ tj ∀i, j
(1)
If a linking trajectory involves a regrasping operation its cost is set to a very high value. The cost of the arcs of the graph is the sum of the cost of the linking trajectory it represents and the cost of the previous polishing trajectory (i.e. the one represented by the initial node of the arc). The topology of the graph allows the use of the Bellmann algorithm [4] in order to find the sequence of trajectories with minimum cost:
Optimize-Trajectories(sc ) Apply the Bellmann algorithm to find the sequence of trajectories st with minimum cost corresponding to the given sequence sc of polishing curves. C = cost of st RETURN (st ,C)
nf PSfrag replacements
ni
END
Due to the presence of an obstacle, the path planning module could modify a linking trajectory with a considerable increase in the cost. In this case, all the linking trajectories connecting the same two polishing curves should be, probably, also modified. The costs of the modified linking trajectories replace in the graph to the initial ones, and the optimization procedure is executed again.
3.2
Path planning module
The path planning module uses a collision map based on an approximate cell decomposition of the Configuration Space [3] corresponding to the three first links of the robot. It is built as follows for every polishing cell: Collision-map() 1- Partition the Configuration Space into a regular grid. 2- Use I-COLLIDE [1] to verify if for the center of each cell there is any intersection between the objects of the environment and the robot, considering the three last joints and the grasped part included in a sphere. Mark the cells as free cells if there is no intersection, and as collsion cells otherwise. 3- Expand the collision space by marking as collision cells those that are neighbour to any collsion cell found in the previous step. 4- Built bigger parallelepiped cells by joining adjacent free cells when possible. 5- Identify free subspaces. 6- Built a graph for each subspace, the nodes being the cells of the partition and the arcs connecting adjacent cells. 7- Find the paths between any two nodes of the graph (using a modified version of the Fulkerson algorithm [4]) END
As an example Figure 2 shows a partition of the Configuration Space with three subspaces. It has been
c0
c1
c2
Figure 1: Graph representing a sequence of three polishing curves, which can be performed by two, three and two polishing trajectories, respectively.
obtained from an initial grid of 64,000 cells (Section 4). The path planning module is devoted to find collision-free paths between the contact configurations corresponding to the end and to the beginning of two consecutive polishing trajectories. Let ci and cf be two of such configurations. Let c0i and c0f be two configurations located, respectively, at a given distance d from ci and cf in the direction of the z-axis of the reference frame of the corresponding polishing location. The distance d is defined by the user. The path p connecting ci and cf is decomposed into: • pi : a rectilinear path in cartesian space connecting ci with c0i . • ps : a path connecting c0i and c0f in joint space. • pf : a rectilinear path in cartesian space connecting c0f with cf . These paths will be computed by the path planning algorithm, which uses the following tools. Validation tool: Given a rectilinear path s in joint space, it verifies if s is collision-free.
Validate(s) Discretize s into a finite set of configurations FOR each configuration
Detect any collision using I-COLLIDE [1] between the robot (including the grasped part) and the objects of the environment IF a collision is detected RETURN non-valid
shows the path p0 searched in the collision map and the corresponding smoothed path p. Finally, the path planning algorithm is as follows. Path-Planning(ci ,cf , d) Find c0i and c0f as the configurations located at a distance d from ci and cf , respectively, in the direction of the z-axis of the reference frame of the corresponding polishing location.
ELSE RETURN valid END
pi = rectilinear path in Cartesian Space between ci and c0i
Smoothing tool: Given a trajectory p composed of a set of linear segments, it finds a collision-free smoother trajectory p0 .
ps = rectilinear path in Joint Space between c0i and c0f pf = rectilinear path in Cartesian Space between c0f and cf
Smooth(p) 1- Discretize each segment of p into a finite set of configurations
Validate(ps )
2- Generate a graph with these configurations as nodes, and with the rectilinear paths connecting any two nodes as arcs
RETURN (pi ∪ ps ∪ pf )
IF ps is not valid ps =Search(c0i , c0f ) END
3- Apply the Dijkstra algorithm [4] to find the shortest path p0 connecting the initial and the final nodes 4- Validate(p0 ) 5- IF p is not valid, eliminate the segments of p that are not valid and GOTO 3 6- ELSE RETURN p0 END
Search tool: Given two configurations c0i and c0f finds a collision-free path between them. Search(c0i , c0f ) Find two configurations c00i and c00f of a free subspace, which are, respectively, the closest configurations to c0i and c0f .
4
A Case Study
This section presents the following example: • The task is performed by a RX-90 St¨aubli robot. • The part to be polished is a semisphere. • The polishing cell has two polishing stations, each one with only one polishing location, and one obstacle (Figure 5). • Four polishing curves have been described over the part (Figure 4): - The first three, described by 10 reference frames, are to be performed at polishing station no 1. - The last one, described by 20 reference frames, is to be performed at polishing station no 2.
p0 = trajectory between c00i and c00f obtained from the collision map p = trajectory p0 including the segments between c0i and c00i and between c00f and c0f
• Joint 6 has a finite range.
Smooth(p)
• The part can only be grasped in a way.
RETURN p
As a result of these initial conditions, and taking into account the inverse kinematics, each polishing curve can be performed by 12, 8, 8 and 114 polishing trajectories, respectively.
END
Since the collision map is built in a very conservative way, the two configurations c0i and c0f will probably not belong to any free cell. However, it is assumed that a free path exists connecting them to a free subspace, since the environment in a polishing cell will not be very clustered. As an example Figure 3
- All of them can be executed in either sense.
The program runs in a Silicon Graphics workstation (175 MHz R10000 Indigo2 ). The two phases of the program synthesis are the following.
Otimization phase: The graph is generated in 4.3 seconds and the optimum polishing trajectory sequence is found in 0.01 seconds. Path planning phase: The collision map is generated with: • An initial partition of 64,000 cells: - Joint θ1 : Range divided in 40 intervals (each 8o over a range of 320o ). - Joint θ2 : Range divided in 40 intervals (each 6.88o over a range of 275o ). - Joint θ3 : Range divided in 40 intervals (each 7.12o over a range of 285o ). • A radius of the sphere covering the three last joints and the grasped part equal to 400 mm. The collision map is obtained in 43.89 seconds distributed as follows: • The collision detection to determine the free cells is obtained in 40.10 seconds. • The connectivity test to generate the subspaces and the grouping algorithm to form bigger free cells is performed in 3.33 seconds. Three subspaces are obtained, composed of 228, 83 i 55 cells respectively.
5
Conclusions
The manually programming of robotic polishing tasks is difficult and very time-consuming. Therefore, the use of a tool for the automatic programming of these kind of tasks must allow an easier description of the robot trajectories, and the possibility to be done off-line. This paper has proposed a tool for the automatic programming of robotic polishing tasks from the CAD description of the part to be polished. The developed software, besides allowing an off-line determination of the robot trajectories, provides the algorithms to guarantee the optimum sequence and to avoid collisions with the obstacles of the cell.
References [1] Cohen J., Lin M., Manocha D. and K. Ponamgi “I-COLLIDE: An Interactive and Exact Collision Detection System for Large-Scaled Environments” Proc. 1995 ACM Int. 3D Graphics Conference, pp. 189-196. http://haptic.mech.nwu.edu/library/cohenj/acm95/
• The modified Fulkerson algorithm to find the paths connecting any two cells is performed in 0.44, 0.01 and 0.01, respectively, for each subspace.
[2] Ge D., Takeuchi Y. and N. Asakawa “Dexterous Polishing of Overhanging Sculptured Surfaces with a 6-Axis Control Robot”, Proc. of the 1995 ICRA, pp. 2090-2095.
The modification of the Fulkerson algorithms allows to deal with rather big graphs, making the grouping algorithm not critical.
[3] Latombe J. C. “Robot Motion Planning” Kluwer Academic Press, 1991.
The solution path is obtained in 65 seconds by: • Fixing the distance d to 20 mm.
[4] Roy B. “Alg`ebre moderne et th´eorie des graphes” Dunod, 1970.
• Using the collision map to find ps , which is found to be composed of 20 configurations.
[5] Rosell J. “Fine-motion planning for robotic assembly under modelling and sensing uncertainties” Ph.D. Thesis, Polythecnical University of Catalonia, 1998. http://www.ioc.upc.es/˜rosell/tesi.html
• Smoothing with a discretization of 100 points per arc. • Validating the arcs with a step less than 3 degrees. The input and output files of this example, including the simulation, are shown in: http://www.ioc.upc.es/˜ rosell/polishing
[6] Van de Poel P., Witvrouw W., Bruyninckx H. and J. De Schutter “An environment for developing and Optimising Compliant Robot Motion”, Proc. of the 1993 ICAR, pp. 713-718.
m
θ3 Curve 4 θ1
Curve 3
θ2
Curve 2 Curve 1 PSfrag replacements
free subspace
Figure 2: Configuration Space partition.
PSfrag replacements
Figure 4: Polishing curves over a semispheric part.
Free Space
PSfrag replacements
c0i
c00i
c00f c0f Collison Space Figure 3: Trajectory smoothing.
PSfrag replacements
Figure 5: Polishing cell.
