González-Palacios MA^{*}, Ortega-Alvarez CJ, Sandoval-Castillo JG, Cuevas-Ledesma SM and Mendoza-Patiño FJ
Division of Engineering Campus Irapuato-Salamanca, University of Guanajuato, Salamanca Carr - V of Santiago, Community Palo Blanco, Salamanca, Mexico
Received April 08, 2016; Accepted April 27, 2016; Published April 30, 2016
Citation: González-Palacios MA, Ortega-Alvarez CJ, Sandoval-Castillo JG, Cuevas-Ledesma SM, Mendoza-Patiño FJ (2016) The Generalized Architecture of the Spherical Serial Manipulator. Adv Robot Autom 5:148. doi:10.4172/2168-9695.1000148
Copyright: © 2016 González-Palacios MA, et al. This is an open-access article distributed under the terms of the Creative Commons Attribution License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original author and source are credited.
Visit for more related articles at Advances in Robotics & Automation
It is well known that the inverse kinematics problem for the spherical serial manipulator has been solved in the past by diverse methods; but this problem for a generalized architecture based on the Denavit-Hartenberg parameters has not been treated. Therefore, this paper considers such treatment in a geometric analysis to derive a closed-form solution of the inverse kinematics problem, whose algorithm is validated by simulating pick and place operations. With the code implementation of a novel linear tracking algorithm introduced here, this application is accomplished in real time with the aid of a development software devoted to simulate robotic applications in real time, allowing the visualization of the performance of all possible architectures including the eight types defined in this paper; It is also shown that the Stanford arm is comprised within this classification. In order to demonstrate the great potential offered by combining the algorithms released here in simulations for industrial applications requiring a quick response, a case study is presented by taking as examples, the Stanford manipulator and a spherical manipulator with generalized architecture.
Inverse kinematics problem; Industrial serial manipulators; Hartenberg-Denavit notation; Real time simulation; Linear path tracking; Robot architecture.
Some architectures of serial manipulators like the RRP have been studied in different ways, for instance, in [1] a RRP manipulator is studied to solve the inverse kinematics problem, IKP for short, near singularities applying the least-square method. Furthermore, by Saeidpourazar [2,3] the forward and inverse kinematics problems are analyzed in a RRP nanomanipulator called MM3A, which is able to perform specific tasks. It was also developed a controller which evaluates the vision and strength of the MM3A.
A numerical method that solves the IKP of six-degree-of-freedom manipulators with combinations of revolute, prismatic or cylindrical joints, is proposed in [4]. A similar study in [5] shows an algorithm for the solution of the inverse kinematics problem of six- or fewer degree-of-freedom manipulators, where the PUMA robot is analyzed as a case study, and being implemented in the KINEM package, which is a software that solves the inverse kinematics problem of several serial manipulators.
DYNAMAN [6], is another simulation software package developed in FORTRAN, where a method to formulate the dynamic equations is applied on serial robots with multiple links, with either revolute or prismatic joints. This software does not have an interface to modify the DH parameters in a simple way. Besides, the model generated lacks of details.
SYMORO [7] and OpenSYMORO [8] is an open source software package developed fundamentally in Pythom dedicated to the symbolic modeling of robots. This package provides support to robot models with flexible joints and to mobile robots. It offers support to serial robots with open and closed chains. A visualization tool to perceive the robot structure is also provided. Another software Package, RobSim [9], whose platform is MATLAB, is able tosimulate five manipulator types: spherical, cartesian, cylindrical, and two architectures of the articulated robot (KAU) PYR and RPR, where link dimensions and robot poses can be specified. It also displays the workspace in 2D.
Some references discussed the IKP for different architectures in the same configuration as in [10], which is obtained for a 5R manipulator using Clifford’s exponential algebra, it is also presented in [11] a unified solution in closed form of a serial robot with six-degree-offreedom by Pieper’s geometry or the Duffy’s geometry. On the other hand, Pieper [12], studies rigid body motions onsix-degree-of-freedom manipulators, with revolute or prismatic joints. FORTRAN is applied for the position analysis and trajectory generation. By means of using velocity methods and Newton-Rapshson technics, numeric solutions of the IKP of the general case are presented. Although Pieper’s work is focused in the methodology required to solve any type of manipulator with six-degree-of-freedom, only presents the study case of the Stanford manipulator, where the equations to obtain the joint variables are shown.
Paul and Shimano [13], provide rules to assign coordinate frames to manipulator links, including simple cases and prismatic joints. In this work, the Stanford manipulator is presented as study case to prove their algorithm to solve position and orientation.
Khalil and Murareci [14] establish the possibility of considering special values of the geometric parameters of manipulators to take the characteristic polynomial to the simplest form using a minimum number of equations. This polynomial, for special architectures, can be obtained numerically. The RRP architecture is studied only when α_{1} = nπ and α_{2} = nπ (the first three axes are parallel), besides, an equation for each joint variable is not presented explicitly.
Much of the kinematic analysis presented in the literature provides numerical solution approaches, as in the case of [15], where a finite element method is applied to solve the forward kinematics problem of the Stanford manipulator using the software Maple V. A probabilistic approach, specifically the Monte Carlo method, is applied in [16] to model the kinematic and dynamic random errors of various manipulator parameters, such as those related to the Stanford manipulator. In [17] the equations of motion are developed for any manipulator with two - or three-degree-of-freedom, where the PUMA and the Stanford robots are presented as case studies.
An important subject is the validation of the results obtained in mathematical models with the application of computer packages for simulation. For example, in [18] are implemented in LabVIEW the forward kinematic and the dynamic analysis of a SCARA manipulator, whereas in [19], MATLAB is applied to solve the forward kinematics problem of a spherical manipulator by implementing a FPGA.
It was found, in general, that the specific solution of the IKP of the spherical manipulator is based on either the basic architecture or the architecture defining the Stanford arm, but to the best of our knowledge, the solution to a generalized architecture has not been reported explicitly in the literature. This generalized solution involves the formulation that embrace eight different possible architectures that the spherical manipulator can hold depending on the values of the first two twist angles according to the Denavit-Hartenberg notation [20].
The generalized closed-form solution of RRP serial manipulators presented in this paper, is an important contribution to the research and development field, since the resulting algorithm, represents a powerful tool to study in real time, the motion of all possible architecture combinations within the same framework.
In this research work, a section is dedicated to establish the guidelines of what we call the generalized architecture of the spherical manipulator. Then, we define the eight types of the generalized spherical manipulator, followed by the formulation of the inverse kinematics solution, which in most cases is represented as a closed-form solution. This formulation includes the pseudo-code that was applied as template to implement the code in ADEFID’s platform [21]. We have dedicated a section to present an algorithm that generates intermediate poses by providing a single parameter, once the initial and final poses of a linear trajectory have been defined.
In the last section, we present a case study related to a simulation of pick and place operations. We integrate in the simulation, the algorithm for the inverse kinematics solution and the algorithm for the linear trajectory planning. In order to provide a closer taste of the performance, sets of frames are sequentially presented. The simulation is running in real time within the software developed for this application.
The manipulator designed with spherical architecture for the positioning of the wrist center point, is the well-known Stanford arm, whose pioneer model is shown in Figure 1a, while Figure 1b shows a more up-to-date version.
The full architecture of the manipulators described above is identified as RRPRRR. Since the last three joints are connected with the architecture of a spherical wrist (RRR), we will refer to these type of manipulators by the first three joints only, namely, the RRP spherical manipulator.
Our study is focused in the derivation of the inverse kinematics solution for the positioning of the wrist center point of what we call the generalized architecture of the spherical manipulator, in other words, according to the definitions of the links parameters following the Denavit-Hartenberg’s notation [20], DH notation for short, all link offsets and link lengths are not zero.
The skeleton representation of the basic architecture of the spherical manipulator along with the corresponding DH parameters, is shown in Figure 2, based on the values given in Table 1, where all link lengths a_{i}, as well as b_{2} are zero. The architecture of the Stanford manipulator, shown in Figure 3, is obtained from the basic architecture of the spherical manipulator by setting b2, the offset of the second link, not equal to zero, as shown in Table 2. Now, the generalized architecture, with the parameters given in Table 3, is plotted in Figure 4.
Link | θ_{i} | b_{i} | a_{i} | a_{i} |
---|---|---|---|---|
1 | θ_{1}* | θ_{1} | 0 | 90° |
2 | θ_{2}* | 0 | 0 | -90° |
3 | 0 | b_{3}* | 0 | 0 |
*Joint variables
Table 1: DH parameters of the spherical architecture.
Link | θ_{i} | b_{i} | a_{i} | a_{i} |
---|---|---|---|---|
1 | θ_{1}* | b_{1} | 0 | 90° |
2 | θ_{2}* | b_{2} | 0 | -90° |
3 | 0 | b_{3}* | 0 | 0 |
*Joint variables
Table 2: DH parameters of the stanford architecture.
Link | θ_{i} | b_{i} | a_{i} | a_{i} |
---|---|---|---|---|
1 | θ_{1}* | b_{1} | a_{1} | α_{1} |
2 | θ_{2}* | b_{2} | a_{2} | α_{2} |
3 | θ_{3} | b_{3} | a_{3} | α_{3} |
*Joint variables
α_{1}=90°,270°
α_{2}=0,90°,180°,270°
Table 3: DH parameters of the generalized spherical architecture.
Applying the same concept introduced in [22] regarding the manipulators’ architecture, we define here eight different types depending on α_{1} and α_{2} values. Thus, α_{1} can be either 90° or 270°, if the manipulator is right shoulder (R) or left shoulder (L), respectively. Whereas α_{2}, which defines the direction of motion of the wrist center point while the manipulator is set at the zero configuration with b_{3} ≠ 0, can hold 0, 90°, 180° , and 270°. Table 4 shows the nomenclature defined for this classification, and Figures 5 and 6, the skeleton representation of right shoulder and left shoulder.
Architecture | Description | a_{1} | a_{2} | |
---|---|---|---|---|
RD | Right Shoulder | Down Wrist | 90° | 90° |
RU | Up Wrist | 270° | ||
RE | External Wrist | 0° | ||
RI | Internal Wrist | 180° | ||
LD | Left Shoulder | Down Wrist | 270° | 270° |
LU | Up Wrist | 90° | ||
LE | External Wrist | 180° | ||
LI | Internal Wrist | 0° |
a and b are slope and intercept of regression line, respectively, SD=Standard deviation for n=3 observations, RE=Relative error
Table 4: Classification according to the twist angles.
In this section, we establish an algorithm that describes the inverse kinematics solution of the generalized spherical architecture RRP, with spherical wrist. The approach presented here, holds the eight architectures described in Section 3, nevertheless, we select the RD type to show the variables and to state their geometric relationship that will be applied along the formulation. Therefore, we depart from the fact that except for the joint variables, we know all the values given in Table 5. We also assume that the position of the wrist center point p=(px, py, pz)^{T}, is known.
θ_{i} | b_{i} | a_{i} | a_{i} |
---|---|---|---|
θ_{1}* | b_{1} | a_{1} | 90° |
θ_{2}* | b_{2} | a_{2} | α_{2} |
θ_{3} | b_{3}* | a_{3} | α_{3} |
*Joint variables
Table 5: DH table for the right shoulder architecture.
To obtain θ_{1}, the joint variable that orientates x_{1} with respect to x0, we use Fig. 7 as reference, where all the linear dimensions shown, lie in parallel planes to the x_{0}-y_{0} plane. Thus, θ_{1} is obtained as
(1)
From eq. (1), is related with =
(2)
while β is associated with h and r as, with
(4)
In eq. (4), Further down we will take into account that and for i=1,2,3. It is important to note that the equations derived for the inverse kinematic solution are obtained for an arbitrary value of α2, and the four values for the architectures defined here become particular cases Figure 7.
Now, to obtain the joint variable that orientates with respect to we use Figure 8, in this case, all the linear dimensions shown, lie in parallel planes to the plane. Thus, is obtained as
(5)
In eq. (5), is associated with a_{2}, a_{3} and a projection of b_{3} as,
(6)
While is related with d and f by,
(7)
where,
(8)
(9)
Now, a projection of b3 is related to a2, a3 and e, namely,
(10)
with
(11)
To solve θ_{1} and θ_{2} from eqs. (1) and (5), respectively, we need , β, , and . From eq. (2) we see that depends on the position of the wrist center point, which is given, but the other three angles, are functions of b_{3}, therefore, we must solve eq. (10) first, which for arbitrary values of α_{2}, must be evaluated numerically. However, if a_{1} = 0, then b_{3} is obtained in closed-form as,
(12)
A similar analysis can be performed to solve the inverse kinematics of the left shoulder manipulator. Now, for the eight types defined in Section 3, a closed-form solution for b_{3} is also obtained. Taking into account that b_{3}> 0, there are two possible solutions for a given architecture, and they depend on the position of the manipulator’s body, which is represented by the first joint. The first set of solutions is listed in Table 6, while the second set, in Table 7. To the best of our knowledge, these sets have not been reported in the literature.
Arch. | b_{3} | θ_{1} | θ_{2} |
---|---|---|---|
RD | |||
RU | |||
LD | |||
LU | |||
RE | |||
LE | |||
RI | |||
LI |
Table 6: Joint variables according to the eight architectures. First body solution.
Arch. | b_{3} | θ_{1} | θ_{2} |
---|---|---|---|
RD | |||
RU | |||
LD | |||
LU | |||
RE | |||
LE | |||
RI | |||
LI |
Table 6: Joint variables according to the eight architectures. Second body solution.
To illustrate the two solutions to reach a given wrist center point, an example of a RD manipulator is presented here. The coordinates of p are (435,78,601) mm, and the two solutions together with the design parameters are shown in Table 8. The simulation is achieved in ADEFID’s platform [21], and Figure 9 illustrates the two poses of the manipulator.
Link | θ_{i} (deg) | b_{i}(mm) | a_{i} (mm) | a_{i} (deg) |
---|---|---|---|---|
1 | 30*, 170.35** | 300 | 100 | 90 |
2 | 110*, -137.31** | 150 | 100 | 90 |
3 | 0 | 400*, 571.5** | 75 | 0 |
*Body solution 1, **Body solution 2
Table 8: DH parameters for the solutions of the RD architecture.
With the closed-form solution for the inverse kinematics positioning approach, above introduced, we have derived a pseudocode that consider all possible solutions in which b_{3} can be evaluated with no need of a numerical solution. Furthermore, a_{1} and a_{2} are symbolically expressed so that not only the eight architecures are contemplated but also those architectures with an arbitrary value of a_{2} if a_{1} = 0. Such pseudo-code is listed next:
Note that two arguments should be passed when Set Inverse Position ( ) is called, namely,
• The DH parameters of the manipulator through a structure defined as DH, which stores the values θ_{i}, b_{i}, a_{i}, and αi, with I=1,2,…,6.
• The desired position vector p of the wrist center point.
• Now, the pseudo-code for the full inverse kinematics solution is readily defined as:
In this case, besides the argument DH, there are other two arguments to pass when calling Set Full Inverse ( ):
• The desired orientation of the end effector given by Q.
• The desired position vector of the end-effector reference point d.
In order to better understand the case study presented in the following section, we report here an algorithm devoted to generate discreet poses given by a single parameter and departing from the knowledge of the initial and final poses of a linear trajectory. Any desired pose of the end effector is represented by its coordinate frame associated with a homogeneous matrix T containing the matrix Q and the vector d, which respectively represent the frame rotation and the position vector with respect to a given reference coordinate frame, as indicated in eq.(13).
(13)
Once the initial and final frames, and of the corresponding poses are defined by and respectively, intermediate poses in a line path, represented by , can be readily obtained with the aid of a single parameter , with . To achieve this, it is necessary to define some invariants, such as vector d, defining the position vector of the origin of frame with respect to frame and the roll, pitch and yaw angles, which we denote as . These angles define the orientation of frame with respect to frame by performing basic rotations about represented as respectively. In Figure 10 we can observe the relationship between the mentioned poses. The function that evaluates the invariants is named Set Invariants ( ), and the pseudo-code is presented below:
Now, with the invariants defined with Set Invariants ( ), it is possible to obtain any intermediate pose by calling the function named Get Pose ( ), whose pseudo-code is given as:
Functions Get Rot Mat From Pose ( ) and Get Vec From Pose ( ) take care of retrieving respectively, Q and d from a given T matrix. Whereas Get RPY Angles ( ), returns roll, pitch and yaw angles by solving the following equation:
(14)
The results obtained in this paper were validated through an online simulation developed in ADRS (Architecture Design and Robot Simulation) which is an application developed in ADEFID platform. The simulation consists in the execution of a pick and place operation. The full cycle of this task is composed on a set of control poses along the planned trajectory. In this case it takes four poses besides the home pose to complete the task.
In order to have a better picture of the great advantage of applying the linear tracking approach introduced here in combination with the closed-form solution of the IKP, we describe the algorithm that takes the robot smoothly from the initial pose to final pose of the linear trajectory.
To begin with, we distinguish two main control levels in the simulation program. The first level consisting in the invariants definition of a desired trajectory, and the second level, in the execution of the process to move from one control point to another.
Within a complete cycle, the robot is set in different states. For each state the robot moves from the beginning to the end of the linear trajectory. When the robot reaches the end pose of a given state, it is set as SUSPEND state, meaning that the robot waits for the next control step, and a control step might be triggered by an input signal, either virtual or real.
Let us consider that the action to move from pose A to pose B is defined by the state STATE1, and the input signal is the Boolean variable named Task from A to B. Then the pseudo-code to be performed in the first level, which is part of an infinite loop, is defined as follows:
Note that at this control level, the statements are executed only once. Now, for the second level, a switch is applied to consider all the cases established for the simulation. In the pseudo-code presented below, the case STATE1 will be accessed several times until the state is changed to SUSPEND:
Setting the control poses that the manipulator must follow during the simulation execution becomes a simple task due to the visualization aids the program provides to the user, in other words, a dialog with tools like sliding bars helps to evaluate in-line the inverse kinematics. While interacting with the sliding bars the manipulator moves accordingly. Now with the aid of another dialog, the user can set a given position as one of the five control poses mentioned above. Figure 11, displays an image in which the two dialogs are opened together with a sample of a Stanford robot. Note that in the image, Pose A was set by just pressing the button labeled Set From Actual.
Now, we applied the algorithm to a simple case, i.e., the Stanford manipulator, which is set as a LU -manipulator. On the ADEFID platform we simulate it with the parameters shown in Table 9.
θ_{i}(deg) | b_{i}(mm) | a_{i}(mm) | a_{i}(deg) |
---|---|---|---|
θ_{1} | 400 | 0 | -90 |
θ_{2} | 120 | 0 | 90 |
0 | b_{3} | 0 | 0 |
Table 9: DH table, stanford manipulator (LU-manipulator).
We have already indicated that for a given architecture there are two possible solutions with b_{3} > 0, then we present still images of the simulation while performing the task. In Figure 12, four frames show the sequence of the simulation, starting from the top left corner, where the block is picked from the feeding conveyor, and ending to the right bottom corner where the block is delivered. The same simulation is performed in Figure 13, but in this case, with the second solution. These solutions are chosen by setting the variable IsBodySol1 true or false in the Inverse Position ( ) function.
The capacity to import STL files of models created in any CAD software having the feature to export this type of files, is an ADEFID’s advantage that allows to create more realistic simulations. Such task, is achieved through the application of the DrawSTL ( ) function pertaining to the CSTL Draw class. With this function, an OpenGL list for each link of a robot is generated, and all lists are handled to achieve simulations as those shown in Figures 11-13.
As a second example we test the algorithm with the generalized spherical architecture. The DH design parameters applied in this case are given in Table 10. The first and second solutions are shown in Figures 14 and 15, respectively. Considering that it is a generalized architecture, and there is no a specific design of the links, the manipulator is shown in the skeleton form.
θ_{i}(deg) | b_{i}(mm) | a_{i}(mm) | a_{i}(deg) |
---|---|---|---|
θ_{1} | 270 | 153 | 90 |
θ_{2} | 300 | 182 | 90 |
0 | b_{3} | 80 | 0 |
Table 10: DH table of a RD manipulator with generalized architecture.
The unified orthogonal architecture concept presented in [22] for serial 6R manipulators, motivated the idea to extend the concept on spherical serial RRPRRR manipulators, and we were able to derive a formulation to solve the inverse kinematic problem for a generalized architecture, in other words, for cases in which all the Denavit- Hartenberg parameters involved for the positioning problem are not zero.
With the twist angles combination of the two first joints of the generalized architecture of the spherical serial manipulator, eight different types were defined, and it was shown that the Stanford arm belongs to one of these. It was also found that for each type, two possible solutions exist for the inverse kinematics problem on the positioning of the wrist center point.
Although the general solution reported here for the inverse kinematics problem is numerical, we obtained a closed-form solution for the case in which α_{1}=0 with an arbitrary value of α_{2}. Besides, closedform solutions were also obtained for the eight architectures defined in this paper.
We were able to handle all closed-form solutions with the approach of a single algorithm. An original feature of this algorithm is that the user can control the solutions allowing to choose the one that best suits the application requirements. A novel algorithm to follow a linear path of the end effector was also introduced in this paper, knowing its initial and final poses, by controlling the position and orientation along the path with a single parameter. The corresponding pseudo-codes of both algorithms were developed, implemented, and validated within a case study focused in pick and place operations, with the aid of ADEFID through ADRS (Architecture Design and Robot Simulation), which is an open source application dedicated to design and simulate in real time, serial manipulators for industrial and research purposes.
The first author acknowledges the support from SNI, (Sistema Nacional de Investigadores), México. The second to the fifth authors acknowledge the support from CONACYT (Consejo Nacional de Ciencia y Tecnología), México.