Arm Tutorial 3

Linear Movements

Many industrial robotic applications need their tools to be moved in a linear fashion. This is the case when the process itself needs to be applied in a straight line (e.g. welding / cutting along a line). Another case for straight movements is the process of gripping an object. First, the robot programmer usually programs an approach position, which can be driven to with any motion statement. The motion from the approach position to the gripping position is done with a linear motion to avoid collisions between the gripper and the object.

In tricky situations, this linear motion might have to be coordinated with a moving conveyor or other kinematic systems. The advantage of the Microsoft Robotics Studio becomes very visible in these situations; thanks to the integrated physics engine, bad gripping strategies or bad gripper retraction paths will result in contact with the surroundings. This contact automatically causes visible movements of the concerned objects. In older robotic simulation systems, such collisions often went undetected if collision detection was turned off or only partially turned on for the wrong objects.

To have our arm moving along linear paths in this tutorial, we added another button for the LIN motion type.

Using the LIN motion type, the robot will move the end-of-arm along a line from its current position to the destination position. Changes in orientation are also adjusted from start to end in a linear fashion.

The next picture shows two positions between which a simple linear move can be executed. First use a PTP motion command to drive to (0.2; 0.2; 0.2); Then insert a minus sign in front of the x value and use ‘drive LIN’.

Especially when using LIN commands, from time to time you will run into a general robotics problem: singularities. Motions that come close or go through singularities result in drastic changes of joint states. At the singularity itself, some joints would have to accelerate to an infinite velocity to do this motion. In real life, this is where robots will stop the motion since real joints can not accelerate this way. So to solve this, robot programmers make sure that there are no singularities in or close to the path. In the simulation world we get around this problem since we have not as strict limitations concerning joint speeds as in reality (There is not an infinite value in the simulation either, but the simulated robot will minimally leave the desired path). E.g. try (x: 0.5; y: 0.215; z: 0; r: 0; p: 90; y: 0) LIN to (x: 0.578; y: 0.215; z: 0; r: 0; p: 90; y: -0) Axis 4 would have to accelerate to an infinite speed close the target position. For a more detailed explanation, please refer to J. Craig, "Introduction to Robotics: Mechanics and Control", Addison Wesley Longman Publishing Co, 1986, page 6,146 ff.

Coding for Arm Tutorial 3:

Arm tutorial 3 allows executing LIN motions. The calculations for LIN motions are done within a new motion planning service for this tutorial. This tutorial also introduces an abstract service that defines the state and the interface needed for a general motion planning service. This abstract service can serve as a basis for different implementations of a motion planning service.

Arm Tutorial 3 Services Overview:

New services for arm tutorial 2:

·        Armtutorial3Dashboard: User Interface with added button to command LIN motion

·        Armtutorial3MotionPlanning: Added LIN motion capability

·        UniversalMotionPlanning: Abstract Service that defines state and interface for the motion planning

Handling a LIN request:

After sending a LINMove message from the dashboard service to the motion planning service, the LINMove Handler is executed.

Here you can see that the ‘LINMove’ type is taken from the abstract service definition, the universal motion planning service. ‘ump’ stands for the namespace ‘KUKA.Tutorials.UniversalMotionPlanning’.

The calculations for the LIN motion are described in the following sections.

Linear ramp PTP movement (service classKukatutorial3motionplanningService, service handler method LINMove)

Fig. 1: Linear PTP movement

This method calculates the sampling point vectors for position and RPY - orientation for a linear point to point movement. Further information about our implementation can be found in (1).

From the given angular joint values we calculate the cartesian position and RPY - orientation using the direct kinematics transformation service:

Next we compute the difference vectors for the position and orientation.

The total distance between the start end the end position can be calculated through [2]:

Also we calculate the angular 'distance' within the angular vector space:

The movement along the velocity ramp profile is calculated analogous to the synchronous PTP movement in arm tutorial 1. For a detailed explanation refer to arm tutorial 1.

Now we determine the top of our velocity ramp:

Next we calculate the times for the acceleration phase, deceleration phase and total movement:

The position and orientation must reach their final values at the common time. We compare the time we need to get to the target position with the time we need to reach the final orientation. The maximum becomes the base for further calculations:

According to arm tutorial 1 we adapt the top velocity level to the new time base:

Also we have to adjust the times for the acceleration phase, deceleration phase and total movement:

 

Next we determine the count of sampling points for our linear PTP movement. The acceleration phase lengths, and the entire motion process time are divided into time slices with the period time (SAMPLERATE) [11] to match the conditions:

As mentioned in arm tutorial 1, , andwon't match an integer multiple of in general. Like in arm tutorial 1, an implementation for a more accurate solution is left to the user as an exercise.

Via [3], [5] and [11] we calculate the sampling point vectors for position and orientation for a specific time:

Finally the inverse kinematic is calculated by the transformation service and the resulting joint angles are appended to the joint angle command list.

Linear PTP movement

 

The distance vector from the start positionto the final positionmay be stated as:

[1]

The Euclidean norm returns the scalar distance between the start and the end position:

[2]

The unit vector points from into the direction of:

[3]

Next we define the side conditions for a strictly increasing function that relates the covered distance to the time:

,

[4]

Thus the position and orientation for a time can be expressed as:

[5]

Like in the arm tutorial 1 the velocity profile for our motion should be a ramp. A detailed description about the ramp velocity profile can be found in arm tutorial 1:

[6]

As in arm tutorial 1 our side conditions are:

[7]

[8]

The first integral over time results to the velocity function:

[10]

Through the appliance of side condition [8] on [10] we get:

[9]

Finally we calculate the distance equation through another integration of [10]:

[11]

Legend:

: = Start position

: = End position

: = Difference vector from start to end position

: = Vector functions for position and orientation

: = Stretch of way function

: = Unit vectors pointing from start to destination

: = Path vector length

: = Acceleration

: = Velocity

: = Acceleration phase length

: = Deceleration start time

: = Total motion time

: = Common total motion time

: = Count of sample points

: = sample point period time

References

(1) W. Weber, "Industrieroboter: Methoden der Steuerung und Regelung", Fachbuchverlag Leipzig, 200