Department of Product and Production Development Master’s Program in Production Engineering CHALMERS UNIVERSITY OF TECHNOLOGY Gothenburg, Sweden 2014 Defining User-friendly Methodology to Create Advanced Mechanisms in DELMIA V5 Master’s Thesis in the Production Engineering Master’s Degree Program ILKER ERDEM 1 Department of Product and Production Development Master’s Program in Production Engineering CHALMERS UNIVERSITY OF TECHNOLOGY Gothenburg, Sweden 2014 Defining User-friendly Methodology to Create Advanced Mechanisms in DELMIA V5 Master’s Thesis in the Production Engineering Master’s Program ILKER ERDEM iii Defining User-friendly Methodology to Create Advanced Mechanisms in DELMIA V5 Master’s Thesis in Production Engineering ILKER ERDEM © ILKER ERDEM, 2014 Master’s thesis / Department of Product and Production Development Chalmers University of Technology Department of Product and Production Development Division of Production Engineering Chalmers University of Technology SE-412 96 Gothenburg Sweden Telephone: + 46 (0)31-772 1000 iv ACKNOWLEDGEMENTS In the accomplishment of this thesis work many have contributed, but the first and most important of all is my supervisor, Henrik Kihlman. I take this opportunity to thank him for his patience, generosity and strong belief in my efforts. Without his support and guidance, it would have been a very troublesome journey to embark and continue. I also take this opportunity to express my gratitude to Peter Helgosson, a colleague of my supervisor and valuable member of Prodtex family, for his support in this thesis work. It has always been inspiring for me to see people who share the same passion for robots that I have carried in my all life. I, therefore, deeply thank Peter for his guidance, cordial support, important information and sincerity, which significantly helped me finish this assignment. Another very important person who provided me the stepping stone is Torbjörn Jakobsson of Prodtex family. By his earlier work on hexapods and his efforts to create a kinematic device, I had been able to acquire the necessary knowledge and understand the dynamics behind a mechanism creation in DELMIA V5. Hence, I am very glad that I have been able to complete his work, without whom I believe this thesis work would have never been completed. I am also obliged to say how grateful I am for the support and information that Mr. Fredrik Palmquist of Exechon family, Mr. Cyrille Froissart of Dassault Systemes, and Mr. Torgny Brogårdh of ABB provided. With their contributions, I have been able to move forward beyond the scopes of expectations. Lastly, I would like to express countless thanks to my parents, my brother and friends for their constant encouragement and support without which success would not be achievable at all. v Defining User-friendly Methodology to Create Advanced Mechanisms in DELMIA V5 Master’s Thesis in Production Engineering Master’s Program ILKER ERDEM Department of Product and Production Development Division of Production Engineering Chalmers University of Technology ABSTRACT The main subject and aim of this thesis work are to create a methodology to define forward and inverse kinematics for advanced mechanisms such as robots with parallel and hybrid structures for the use in the project named LOCOMACHS (Low Cost Manufacturing and Assembly of Composite and Hybrid Structures) in DELMIA V5. These respective mechanisms are Hexapod/Flexapod 6P, Exechon and Gantry- Tau robots. The methodology created for this thesis work is building these robots with their forward and inverse kinematics definitions and testing the outcome. The forward kinematics aspect covers the building of the respective mechanisms whereas the inverse kinematics aspect includes the investigation of relevant theory and transfer of it to a C-file where this file is compiled to the use of DELMIA V5. Testing aspect focuses on comparing the results achieved with a C-file and MATLAB to the actual values coming from DELMIA V5. Hexapod and Flexapod 6P mechanisms are investigated and simulated in DELMIA V5 in complete structure while Exechon and Gantry-Tau robots are built only for their parallel structures. Keywords: DELMIA V5, parallel kinematics, forward kinematics, inverse kinematics, Hexapod, Exechon, Gantry-TAU, simulation. vi TABLE OF CONTENTS 1. INTRODUCTION ....................................................................................................................................... 1 1.1. OBJECTIVES AND SCOPE ................................................................................................................ 1 1.2. METHODOLOGY ............................................................................................................................ 2 2. INTRODUCTION TO ROBOTS: HEXAPOD/FLEXAPOD 6P, EXECHON AND GANTRY-TAU ....................... 3 2.1. HEXAPOD/FLEXAPOD 6P ............................................................................................................... 3 2.2. EXECHON ....................................................................................................................................... 4 2.3. GANTRY-TAU ................................................................................................................................. 5 3. THEORY .................................................................................................................................................... 7 3.1. FORWARD KINEMATICS ................................................................................................................ 7 3.2. BUILDING MECHANISMS AND FORWARD KINEMATICS IN DELMIA V5 ........................................ 9 3.2.1. CREATION OF MECHANISMS IN DELMIA V5 .................................................................................. 9 3.3. INVERSE KINEMATICS .................................................................................................................. 17 3.3.1. CREATION OF INVERSE KINEMATICS IN DELMIA V5 .................................................................... 18 3.3.2. THE ANALYSIS OF C-FILE FOR INVERSE KINEMATICS IN DELMIA V5 ............................................ 23 3.3.3. COMPILATION OF C-FILES ............................................................................................................ 27 4. THEORY OF INVERSE KINEMATICS FOR RESPECTIVE ROBOTS ............................................................. 28 4.1. HEXAPOD/FLEXAPOD 6P INVERSE KINEMATICS ......................................................................... 28 4.2. HEXAPOD/FLEXAPOD 6P – TRANSFER OF THEORY TO A C-FILE .................................................. 31 4.3. EXECHON INVERSE KINEMATICS – THEORY ................................................................................ 38 4.4. THEORY OF EXECHON TO C-FILE ................................................................................................. 40 4.5. GANTRY-TAU ROBOT ................................................................................................................... 42 4.6. THEORY OF GANTRY-TAU ROBOT TO C-FILE ............................................................................... 47 5. RECOMMENDED COURSE OF ACTION FOR MECHANISM BUILDING IN DELMIA V5 – THE USER- FRIENDLY METHODOLOGY ......................................................................................................................... 50 6. RESULTS AND DISCUSSION ................................................................................................................... 54 7. CONCLUSION ......................................................................................................................................... 57 REFERENCES ................................................................................................................................................ 58 APPENDICES ................................................................................................................................................ 59 APPENDIX A: HOW TO SET UP ENVIRONMENT FOR FORWARD AND INVERSE KINEMATICS ................. 59 APPENDIX B: BUILDING OF FLEXAPOD 6P ............................................................................................... 61 MECHANISM CREATION OF FLEXAPOD 6P ............................................................................................. 61 vii TESTING OF THE FLEXAPOD 6P’S FORWARD KINEMATICS .................................................................... 80 THE CREATION OF INVERSE KINEMATICS .............................................................................................. 80 TESTING OF THE INVERSE MECHANISM ................................................................................................ 84 THE C-FILE FOR INVERSE KINEMATICS OF FLEXAPOD 6P ....................................................................... 85 APPENDIX C: THE CREATION OF INVERSE KINEMATICS FOR HEXAPOD ................................................. 95 THE INVERSE KINEMATICS CREATION .................................................................................................... 95 THE C-FILE FOR HEXAPOD ...................................................................................................................... 98 APPENDIX D: THE FORWARD AND INVERSE KINEMATICS CREATION OF EXECHON ............................. 107 FORWARD KINEMATICS: EXECHON...................................................................................................... 107 EXECHON INVERSE KINEMATICS .......................................................................................................... 125 EXECHON C-FILE ................................................................................................................................... 128 APPENDIX E: GANTRY-TAU ROBOT ....................................................................................................... 136 FORWARD KINEMATICS: GANTRY-TAU ................................................................................................ 136 INVERSE KINEMATICS: GANTRY-TAU ................................................................................................... 144 FORWARD KINEMATICS THEORY OF GANTRY-TAU ROBOT ................................................................. 148 THE C-FILE FOR GANTRY-TAU ROBOT .................................................................................................. 150 APPENDIX F: COMPILATION OF C-FILES ................................................................................................ 158 COMPILATION IN 64-BIT OPERATING SYSTEMS ................................................................................... 158 COMPILATION IN 32-BIT OPERATING SYSTEMS ................................................................................... 161 APPENDIX G: MATLAB FUNCTIONS ....................................................................................................... 163 HEXAPOD INVERSE KINEMATICS .......................................................................................................... 163 FLEXAPOD INVERSE KINEMATICS ......................................................................................................... 165 EXECHON INVERSE KINEMATICS .......................................................................................................... 167 GANTRY-TAU FORWARD KINEMATICS ................................................................................................. 169 GANTRY-TAU INVERSE KINEMATICS .................................................................................................... 170 viii DEFINITION OF TERMS AND ABBREVIATIONS Actuator is a mechanism that initiates and control the motion of a system. Degrees of freedom (DOF) is the term that describes the independent motions that a body is allowed to do. CAD-model is a 2D/3D drawings or solid structure of parts in a modeling environment. End-effector is the utility of a robot that interacts with the objects that are not part of the robot. Joint is the center of motion where two solid structures of a robot contact each other. Prismatic joint (P) is a joint type with one translational degree of freedom Revolute joint (R) is a joint type with one rotational degree of freedom Universal joint (U) is a two degrees of freedom joint that corresponds to two successively attached revolute joints. Spherical joint (S) is a joint type with three degrees of freedom that allows parts to rotate in all axes freely. Link/leg is the term that defines the solid structure between joints. Kinematic chain is the term employed to describe the order of joints in a mechanism. Serial kinematics machine (SKM) is a robot that the respective joints are successively attached to each other. Parallel kinematic machine (PKM) is a machine that consists of links/legs that operate in parallel axes. Hybrid robot/machine (HM) is a robot that consists of parallel and serial kinematic chains successively. Tool Center Point (TCP) is the tip of the end-effector with respect to which the robot’s interaction with environment is calculated. 1 1. INTRODUCTION The EU financed project ©LOCOMACHS (Low Cost Manufacturing and Assembly of Composite and Hybrid Structures) is a joint adventure research and development program with SAAB AB as coordinator. The project is in partnership with 31 companies of aircraft industry and universities. LOCOMACHS mainly focuses on reduction or eradication of non-value adding operations in manufacturing of aircrafts. Thus, the objectives of the project can be summarized as  Reduction of cost and lead-time  Managing tolerance and variation  Increasing the level of automation  Designing new production methods and systems At this point, this thesis work will fit in the last two objectives (LOCOMACHS 2014). In order to increase the level of automation and set up new rules for manufacturing and design, the simulation of respective ideas become vital. Thus, the necessary means to support new designing ideas must be defined in the chosen simulation environment – DELMIA V5. DELMIA V5 of Dassault Systemes is one of the most advanced simulation tools that enables its users to create, define and control all aspects of a production system. As one of those aspects, DELMIA V5’s Device Building module is a highly capable virtual mechanism creation instrument that defines forward and inverse kinematics of any given mechanism. However, advanced mechanisms such as parallel and hybrid (parallel-serial) robots are not recognized by this module directly via user-interface; thus, this definition of mechanism must be done by using C-code, which is considered to be a very important feature of DELMIA V5. Hence with DELMIA V5’s described feature, the means to support the newly designed manufacturing systems with higher levels of automation for LOCOMACHS project must be defined in terms of kinematic capabilities; and this thesis work is exactly formulated to provide a user-friendly methodology for the partners of project LOCOMACHS to simulate their kinematic devices in DELMIA V5. 1.1. OBJECTIVES AND SCOPE In this thesis work, readers will find answers to how to define advanced mechanisms in DELMIA V5 by both using forward and inverse kinematics definition tools for robot types: hexapod/Flexapod 6P, Exechon and Gantry-Tau robots. So, the objective of this thesis work is to  define a methodology to create advanced mechanisms in terms of forward kinematics  create a methodic application of relevant theory for inverse kinematics to DELMIA V5  continue the methodology to define how to set up the compilation and testing environment.  simulate the respective robots by using the methodology. 2 Then, scope of this thesis work covers:  Creation of methodology  Building of declared robots in DELMIA V5 environment using the methodology  Testing of the prospective robots in DELMIA environment Therefore, the structure of this paper will be as following:  Forward and inverse kinematics creation in DELMIA V5  The analysis of C-files for inverse kinematics  Theory for the given robots in terms of inverse kinematics and its transfer to a C-file  Method employed during the building and solving the problems occurred  The creation of Hexapod/Flexapod 6P, Exechon and Gantry-Tau robots in DELMIA V5 (appendix section) 1.2. METHODOLOGY The scientific inquiry for this thesis work is originated on the question whether it is possible to formulate a methodology that enables a layman user to build advanced mechanisms in a simulation environment such as DELMIA V5 so that element of surprise in terms of unexpected errors is minimized. As Craig (2005) summarizes, the steps that any mechanism creation should cover assembly, kinematics definition and testing. In addition, the knowledge gained from the previous project owner – Torbjörn Jakobsson – and Cyrille Froissart of Dassault Systemes shows that the same way of thinking of Craig’s applies to DELMIA V5 as well. However, the documented information from their work is either limited to serial kinematics machines or only defined within the limits of inverse kinematics for parallel kinematics machines. Thus, the remaining aspects of mechanism creation for parallel kinematics machines are still a black box. Therefore, the experimentation phase should be initiated before defining a user-friendly methodology. This kind of experimentation and thinking was also conducted by Torbjörn Jakobsson from which he was also able to gain great amount of insight regarding advanced mechanism creation in DELMIA V5. By focusing on hexapod robot creation in terms of inverse kinematics definition, he was able to map all the important founding dynamics for inverse kinematics creation and documented it. Thus, it can be hypothesized that by assembling the respective robots for all the steps of mechanism creation it would be possible to record a map of actions from which a user-friendly methodology can be developed. The results of this experimentation and the map of actions that create the methodology is given with details in Chapter 5: RECOMMENDED COURSE OF ACTION FOR MECHANISM BUILDING IN DELMIA V5. 3 2. INTRODUCTION TO ROBOTS: HEXAPOD/FLEXAPOD 6P, EXECHON AND GANTRY-TAU In this chapter, a small introduction will be given to respective robots of this thesis work along with their importance in industry. 2.1. HEXAPOD/FLEXAPOD 6P Hexapod and Flexapod 6P are the same class of robots, where the only difference lies in their design and the structure of the parts used. This difference of design does not affect the kinematics or the idea behind this class. Thus, these robots in this chapter will be described schematically. Hexapod robots, also known as Stewart Platforms, named after the creator D. Stewart, is parallel structure of two platforms connected to each other via prismatic actuators named as legs. As the name suggests these six legs are connected to a base platform in one end whereas the other ends of the legs are attached to a mobile platform (Yang 1998). The design difference between Flexapod 6P and a standard hexapod is that upper attachment points for hexapod are connected to legs via spherical joints while Flexapod 6P has universal joints for upper attachment points and the rotation of legs about their own axis provides the final degree of freedom that a spherical joint grants in a hexapod. This class of robots that is going to be adapted to DELMIA V5 will be utilized in the project called LOCOMACHS in which hexapods will be used as flexible tooling equipment to support and enhance the quality of production in aerospace industry. Figure 1: Hexapod (on the left) and Flexapod 6P (on the right) 4 2.2. EXECHON One of the most successful PKM (Parallel Kinematic Machine) structures Exechon – developed and patented by Karl-Erik Neumann in 2006 – is a tricept-related hybrid machine where a parallel structure of three legs actuated with prismatic joints is followed by an R-R or a spherical wrist. The structure itself was created in Sweden and is currently being manufactured by several companies in the world (Zoppi 2010). The kinematics structure is comprised of parallel and serial parts which are attached successively and creating the hybrid kinematics. The parallel structure has three legs as said above and two of which are identical to each other. These two legs create a common plane meanwhile the third leg’s plane is perpendicular to the plane created by identical legs. The joints for the identical legs follow RR-P-R and those for the third leg are RRR-P-R (Bi 2010). This is illustrated in figure 2. The successively attached serial structure can be a revolute-revolute or spherical wrist. The tool attached to wrist can be used for drilling or milling operations as Bi (2010) states. The complete structure built for DELMIA V5 can be seen in figure 3 . In this thesis work, revolute-revolute wrist is not going to be utilized; and thus, the calculations will be made only for the parallel structure. Figure 2: Exechon's parallel structure S-P-R leg RR-P-R leg RR-P-R leg Prismatic Joint (P) 5 2.3. GANTRY-TAU Gantry-Tau is a parallel kinematics robot patented by ABB. The parallel structure consists of three clusters in which links are attached to mobile platform on different points. The reason that Gantry-Tau robot has gantry term is the fact that the actuated motion provided by three prismatic joints have the same ideology with Cartesian (also known as Gantry) robots. The clusters term used here refer to the group of links where each group connects a prismatic joint to the end-effector. In total, the structure has six links and clustered as 3-2-1. This notation describes the number of links that each cluster has. The kinematic chain of each link is a PRRS and the actuation is in the prismatic joint. The chains and their relations to other parts can be seen in figure 4. (Johannesson 2003) On the other hand, it is important to keep in mind that in practical applications the kinematic chain can be changed to a PSS (Prismatic-Spherical-Spherical). The reason is that the extra DOF that comes with the first spherical joint only provides rotation about link’s own axial axis. Thus, in practice, this has no influence. However, when simulated such extra joint will cause problems; and therefore, the regular PRRS chain should be used as shown in figure 4. Figure 3: Exechon robot as CAD model in DELMIA V5 6 Figure 5: Gantry-Tau model in DELMIA V5 Figure 4: Gantry-Tau robot Z X Y Prismatic Prismatic Prismatic Revolute Revolute Spherical Joints 7 3. THEORY In this chapter, forward/inverse kinematics in general will be described along with their uses in DELMIA. Also, the relevant theory for the inverse kinematics of Hexapod/Flexapod 6P, Exechon and Gantry-Tau robots will be presented along with their respective C-files. 3.1. FORWARD KINEMATICS Before going deep into detail, it is important to define the term, kinematics. Kinematics, then, is the investigation of mechanisms in terms of position, velocities and accelerations without including the forces that set the basis for them (Craig 2005). This kinematics definition, by theory, is divided into two categories where the first analysis method is called forward kinematics. This analysis can be defined as attaching coordinate frames to each link in a robot until the end-effector (TCP) in order to describe the position and orientation of the end-effector in terms of base-coordinate system (Jazar 2010). These terms are shown in the figure 6. Thus; the idea in forward kinematics is to describe the given TCP coordinate system in base- coordinate system by attaching intermediary coordinate frames at every joint. Hence, by propagating from one coordinate frame to the next the end-effector’s orientation and position is described by using each link’s coordinate frame variables where each variable is chosen as a joint value in which actuation by command is possible. However, in order to propagate from one frame to another, a means that includes relevant information about a frame is necessary. This relevant information should include the position of the origin point and the orientation of the consisting XYZ unit vectors with respect to another frame. In kinematics theory, the means to convey this information is achieved with a 4x4 matrix, named Transformation matrix (Craig 2005). Figure 6: Basic terms in kinematics Base coordinate system …… ……. …… ……. TCP coordinate system Link 1 Link 2 Link i 8 To fully understand and describe what transformation operation is, three different coordinate frames A, B and C are shown in figure 7 along with point CP. To describe this point CP in coordinate frame A, transformation matrices between A-B and B-C must be created. A transformation matrix then is composed of rotation and translation and has the following structure. (1.1) notation describes a transformation between A and C coordinate frames in which C is relative to A-coordinate frame. Thus, when multiplied with , any given point or vector in C-coordinate frame is transformed or described in coordinate frame A (Craig 2005). To create this transformation matrix by using all the given coordinate frames, the following formula is applied. (1.2) This formula states that {C} is first described relative to {B}, and then multiplied with the transformation between {A} and {B} in which {B} is relative to {A}. Hence, transformation between {A} and {C} is completed by using an intermediary coordinate frame {B} (Craig 2005). The terms rotation and translation in are the compounds of this matrix where rotation is the unit vector definition of each axis of {C} relative to {A} and translation is the vector between the origin points of {A} and {C} relative to {A}. The last row of this transformation matrix is [0, 0, 0, 1] and this row has no significance but is only useful in terms of making the matrix square (Craig 2005). Rotation Translation 0 0 0 1 = = Figure 7: A, B and C coordinate frames each relative to earlier one. {A} {B} {C} PC XC YC ZC XB YB ZB XA YA ZA CP 9 Hence, the vector CP is multiplied with the transformation matrix and the outcome of this operation is the vector defined in {A}. This operation is formulated as (1.3) When the formula 1.3 is applied, a robot’s end-effector is described through each link’s transformation and the resulting transformation matrix includes variables for the actuators in the robot mechanism. When these variables entered, this transformation matrix yields the position and orientation of end-effector or in other words TCP location and orientation (Craig 2005). This methodology of course can be applied to a parallel structure such as hexapods. On the other hand, the mathematical complexity becomes a great burden and solving these mathematical expressions may not yield an exact result but sometimes estimations due to the necessity for numerical approaches (Yang 1998). Therefore, DELMIA at this point provides a very useful way to create a mechanism and builds the forward kinematics description automatically at the end-effector. 3.2. BUILDING MECHANISMS AND FORWARD KINEMATICS IN DELMIA V5 In this chapter how DELMIA V5 approaches the concept of forward kinematics will be described whereas building the complete mechanisms along with their forward kinematics description will be given in appendix for hexapod/Flexapod 6P, Exechon and Gantry-Tau robots. The information presented in this chapter is based on Cyrille Froissart’s confidential documentation. Thus, due to confidentiality of the document the reference cannot be given. 3.2.1. CREATION OF MECHANISMS IN DELMIA V5 Creation of a mechanism can be achieved in three ways in DELMIA environment. These methods are  Classic method  Frame of Interest Method (FOI)  Frame of Interest and Dress-Up Method In this thesis work only “Frame of Interest Method” is used since it offered simplicity and geometry- independent mechanism creation. FOI method is used by appointing frames (in this case called as Frame of Interest) to the regarding joint locations and creating pre-defined joints from these frames. These pre-defined joints are  Revolute (1 rotational degree of freedom)  Prismatic ( 1 translational degree of freedom)  Universal (2 rotational degrees of freedom)  Cylindrical ( 1 rotational or translational degree of freedom)  Spherical ( 3 rotational degrees of freedom) 10 The creation of a mechanism in DELMIA V5 starts with opening ‘Device building’ module. In this module, the user first creates a mechanism in the node. Afterwards, user defines a fixed part and starts to build the respective mechanism upon that fixed part. To simply illustrate, an example will be given by embarking the FOI method. In this example, one leg of a Flexapod 6P will be used along with the fixed part ‘Base’. First, DELMIA V5 will be opened in ‘Device building’ module. Figure 8: Device Building module in DELMIA V5 In the second step, for each part of the mechanism ‘new component’ is clicked and a separate component is created under the node tree. For this example, necessary parts are  Base  Lower connecting cube  Lower leg connected to base  Upper leg that is connected to lower leg part by a prismatic joints Thus, respective node tree will be looking as in figure 9. Figure 9: Example of a node tree for mechanisms In the third step, necessary CAD-models should be inserted into the respective nodes by using ‘Insert-Existing Component’ commands. Then, the node tree should have the form in figure 10. 11 Figure 10: Leg mechanism with CAD-models inserted In the fourth step, a new mechanism will be created and a fixed part –which in this case is the part called ‘Base’- will be appointed. To achieve this, first ‘New Mechanism’ button must be clicked. Then in the node tree under ‘Applications’ a new mechanism division will be available. To appoint the fixed part, click the ’Fixed Part’ and a respective menu will appear. Afterwards, respective part ‘Base’ must be chosen for this example. In the fifth step, first joint will be created between the cube and the base part. Since the base part is designed to have six legs, in this example only one leg will be demonstrated. For the remaining legs, refer to the appendix. Figure 11: Creation of a new mechanism (1) (3) (2) Figure 12: Creating the fixed part 12 To create a revolute joint, first Frames of Interest (FOIs) will be attached to the respective locations. The first frame will be attached to the base and the second in the cube. The order does not matter, but it is noted that in order to avoid confusion, it is important to follow a pattern. At first, click ‘Frames of Interest’ button and create a Frames of Interest node under both parts – ‘Cube’ and ‘Base’. Then, click on ‘Frame type’ button and place the FOI as shown in figure 13. Then the same procedure will be applied to cube and the result is shown in figure 14. It is important point out that all one-degree-of-freedom joints either translate or rotate about the Z-axis of the FOI. Thus, as seen in figure 13 and figure 14, the rotational axis Z is about to coincide when the joint is created. Figure 14: Cube part with FOI at the center Figure 13: Appointing FOI to 'Base' part (1) (2) (4) (3) (5) 13 Since all the necessary FOIs are attached, the revolute joint now can be created. To create a joint, DELMIA V5 offers various ways. However, as stated before, when FOIs are used creation of joints are easily done by using ‘Joint from axis’. After opening ‘Joint from axis’, a new menu appears where users define the properties of the axis to be created. These features are  Mechanism to which the joint will belong  Joint name  Joint type  Axes required for joint creation. In this case, these features will be Mechanism.1, Revolute and 2 FOIs created for ‘Base’ and ‘Cube’. This is shown in figure 15 . The order of the joints does not matter in this case and ‘Joint name’ section is automatically generated. The ‘Angle driven’ button makes the joint an actuator in the mechanism. When clicked ‘OK’, the cube is automatically attached to the correct location where two FOIs coincide. The result is shown in figure 16. Figure 16: Revolute joint with FOIs (1) (2) Figure 15: Joint creation with FOIs 14 Second part of this mechanism is to connect ‘Lower Leg’ part to the cube with a revolute joint. Again, the same procedure will be followed as for the joint between the base and cube except this time one of the FOIs will be attached to ‘Lower Leg’. The FOIs can be seen in figure 17. When these two FOIs are combined by using the same methodology for the first revolute joint, the lower leg is automatically translated to the position and oriented in a way where two FOIs’ Z-axes coincide. The result is shown in figure 18. Figure 17: FOIs for the second revolute joint Figure 18: The second revolute joint 15 In the third step, a prismatic joint will be created between ‘Lower Leg’ and ‘Upper Leg’ parts. To achieve a correct state with the joint, it is important to place the FOIs in the accurate positions. Specifically, when a prismatic joint is created, DELMIA V5 takes the current positions of each FOI and makes them coincide in Z-axes. However, since the origin points are not necessarily coincided for a prismatic joint DELMIA V5 sets the zero position of this joint in the same coordinates where the respective parts currently are. Therefore, it is important to have each FOI at the same location before a prismatic joint is created. To achieve this, one may consider creating a revolute joint and then deleting it along with the constraints; and afterwards, creating the revolute joint. The second way is to move the mobile part from respective FOI to the coordinates of the one of fixed part in the joint. With the first way chosen, a revolute joint will be created with the same routine for earlier joints. Then revolute joint will be deleted and from the ‘Joint from axes’ button, a prismatic joint will be directly made. Since this joint is appointed as the actuator of the mechanism, the ‘Length driven’ command will be activated. The respective FOIs and the joint creation menu are shown in figure 19 and figure 20. Figure 20: Prismatic Joint and respective FOIs Figure 19: Prismatic Joint menu with 'Length Driven' activated 16 As seen earlier, the revolute joints are not created as actuators; therefore, DELMIA V5 will not be able to simulate the system due to free motion of those joints. However, since this is an illustration to show how mechanism creation works, it would be possible to test the mechanism by making all the joints actuators. This achieved via double-clicking on each revolute joint in mechanism node and activating ‘Angle driven’ field. This way DELMIA V5 will prompt a menu on which the following information can be seen ‘The mechanism can be simulated’. This feature can also be observed by clicking the mechanism properties icon. On the prompted menu, DELMIA V5 displays all the joints created and their respective parts. In this section, a very important aspect is also shown in which the total degrees of freedom of a mechanism can be seen. These degrees of freedom are divided into two sections where one shows Degrees of freedom with command and the other Degrees of freedom without command. The Mechanism Analysis menu is shown in figure 21. In figure 21, it is seen that the mechanism has three joints and only one of them has a command, in other words one of them is only actuated. This means that the rest of the joints are free to respond any action which makes them dangling joints by the terminology employed by DELMIA V5. This does not mean that the mechanism created is incorrect but unfinished. As said earlier, this is only a demonstration and the complete structure will be presented in appendix section of this paper. Thus, in order to simulate the system, the revolute joints will be made actuators. The user must click on each joint created under the ‘Mechanism-Joints’ node in the product tree and double-click on each joint. The same menu for joint creation will be prompted and on that menu, ‘Angle driven’ field should be activated. When repeated for the other revolute joint as well, the mechanism properties menu will display ‘Yes’ for the section ‘The mechanism can be simulated’. Also, it will be seen that degrees of freedom without command will be zero. This can also be seen from the mechanism node in the product tree as shown in figure 22. Figure 21: Mechanism properties menu 17 To see the behavior of the mechanism, it must be jogged. This property is provided by ‘Jog mechanism’ button . When clicked, a new menu will prompt, and on this menu the user will be able to jog the mechanism for given range of joints. The menu and the jogged mechanism can be seen in figure 23. This way DELMIA achieves the forward kinematics of any model needed to be built. It requires no other calculation; and the required transformation matrix is automatically created when the inverse kinematics definition is made – which will be the topic of the next section. 3.3. INVERSE KINEMATICS Inverse kinematics is the way of finding necessary joint values for a given TCP values of a robot. The way of reaching a solution is divided into two methods, algebraic and geometric. Algebraic solution is based on finding joint values by acquiring equations from transformation matrix with given values of TCP. On the other hand, geometric solution is about decomposing the spatial definition of a robot into several planar equations by using vector definitions (Craig 2005). In the case of this paper, the hexapod (Flexapod 6P) uses a geometric solution whereas Exechon and Gantry-Tau robot utilizes both of the Figure 23: Jogging the mechanism Figure 22: Mechanism properties after actuation 18 given ways. The building of inverse kinematics in DELMIA V5 will be the topic of this section whereas the inverse kinematics theory of the respective robots will be presented in the next chapter. 3.3.1. CREATION OF INVERSE KINEMATICS IN DELMIA V5 The inverse kinematics definition in DELMIA V5 is done by the ‘Inverse Kinematics’ icon . When this icon is clicked and the mechanism is chosen, DELMIA V5 prompts a new menu for the definition of inverse kinematics. The menu is show in figure 24. The first tab in the menu is Basic. Mount part section is used to define the part that is attached to the TCP. Mount offset is used for the FOI that describes the TCP’s coordinate frame. Reference part is used to define the coordinate frame that is going to be the reference for calculations where as the Base part is the fixed part of the mechanism. In many cases Base part and Reference part are the same. Approach axis is used to define the main axis of the TCP which in most of the cases is Z-axis whereas Approach direction is the direction that defines the positive direction in calculations whether it is inwards or outwards on Approach axis. It is usually set as Out. The solver type provides options to define the inverse kinematics solution. These options are  Numeric method  Generic method  Device-specific method  User inverse method (use of a C-code). In this paper, the creation of inverse kinematics will be carried out by creating a C-code. On the other hand, it is important to represent how other methods work as well. Thus, simple instructions will be given for them. Numeric method is a built-in feature of DELMIA V5. In this method, solver tries to solve the joint values by using algebraic methods from transformation matrix. The user has no chance to interfere with the calculation but define which joints to be solved. When this method is chosen and ‘Advanced’ button is clicked, a new set of tabs appear in the inverse kinematics menu – which can be seen in figure 25. Figure 24: Inverse kinematics definition menu 19 In ‘Configurations’ tab, DELMIA V5 asks user to flag the postures of the given robot. These postures are flagged as valid or invalid where valid makes the posture of the robot available in the simulation environment. ‘Actuator Space Map’ tab is where the user maps the joints and their mobile parts with the commands for inverse kinematics calculation. In this tab, the user defines the joint map section first where each ‘Degree of Freedom’ is associated with the corresponding joint. For example, for RR mechanism of Exechon’s wrist (revolute and revolute in serial order) dof(1) appoints the first degree of freedom to revolute joint 1 whereas dof(2) appoints the second degree of freedom to revolute joint 2. In the second section of mapping, types of freedom are defined where the options are limited to translational or rotational. In the third section – Kin Axis Type, the main axis of motion is defined. For Kin Part, the mobile part of the joint is appointed. Compute button is used to appoint these values automatically, and it is possible that DELMIA V5 may not guess the entire system correctly. All these sections can be seen in figure 26. ‘Solver Attributes’ tab is used in order to define the parameters for the chosen inverse kinematics method. In this tab, three sections are represented. First, the user is asked to define convergence tolerances for the numeric solution for both angular and linear convergence. In the second section, user decides on which joints to be solved, and in the last section, TCP convergence between Figure 25: Inverse kinematics tabs for numeric method Figure 26: Configurations and Actuator Space Map tabs 20 robot TCP and target location is defined for X, Y, Z directions and Roll-Pitch-Yaw rotations. These sections are unique to each mechanism in hand. This tab can be seen in figure 27 for Exechon’s RR wrist. After defining the necessary tabs, the inverse kinematics now is ready to use. To test its accuracy, click on ‘Jog mechanism’ and the menu with a new tab called ‘Cartesian’ will prompt. The idea with this tab is to use a tag at the predefined TCP location to jog the robot to a certain point by using inverse kinematics calculation. In this tab, the user is allowed to change the TCP from defined point to any desired location as well as to jog the mechanism by using Cartesian coordinate system with respect to any defined coordinate frame. These features can be observed in figure 28. This way a mechanism defined with inverse kinematics can be used in other modules of DELMIA for simulation purposes. Figure 28: Cartesian tab with TCP tag Figure 27: Solver Attributes tab 21 Generic method is used for most commonly adapted structures in the field robotics. These structures defined by DELMIA V5 as kinematic classes are  Cartesian robot ( TTT:RRR)  SCARA robot (TRR:RRR)  Cylindrical robot (TRT:RRR)  Block robot (TTR:RRR)  Bore robot (RTT:RRR)  Articulated robot (RRR:RRR)  Spherical robots (RRT:RRR)  Pendulum robot (RTR:RRR) The meaning of kinematic classes shown in parentheses is that the robot has 2 divided structures. The first structure is the body and shown before the colon. The part after the colon, on the other hand, represents the structure known as mount or wrist. For example, Cartesian robot has three translational joints in the body and this is represented as TTT. The RRR section, whereas, represents the three serially connected revolute joint as a wrist attached at the end-effector. The kinematic classes and the remaining properties for this method are shown in figure 29. When ‘Advanced’ is clicked the same tabs with numeric method appear, whereas the contents of the Solver Attributes tab are different. In this tab, four different sections are shown. First section is named ‘Joints Information’. In this section, the user defines Offsets, Presents, Signs and Order. The ‘Offsets’ are the distances of joints from the original coordinate frame of the joint. Presents are used to inform DELMIA V5 whether the joint should be included in inverse kinematics calculation. ‘Signs’ section decide on the direction of translation or rotation whereas ‘Order’ describes the calculation order that should be taken into account for the given kinematic class. In the second section, ‘Link Lengths’, the offsets are used for rotational joints when their origins are coaxial. Shoulder offsets and arm lengths are only available for articulated robots. ‘Base and Mount Offset’ sections are used to define the transformation for any external coordinate frames that is set by the user for inverse kinematics calculation. ‘Wrist Rotation’ section describes the final rotation of TCP on Figure 29: Generic method and Basic and Solver Attributes tab 22 the wrist. Unless changed, these values represent the same structure defined in forward kinematics building. When these values are set and clicked OK, the robot will be ready for simulation purposes. Device-specific method is used for specific type of robots that are already defined in the library of DELMIA V5. Therefore, only difference of this method from Generic Inverse is that in Solver Attributes tab, DELMIA V5 asks its users to choose the routine name for the specific type of robot. The list of robots and their routines can be seen in figure 30. The last and the topic of this paper is ‘User-inverse’ method. This method is developed by DELMIA V5 in order to enable its users to integrate complicated calculations to a variety of mechanisms. The idea stems from the fact that some types of robots do not use widely known kinematic classes in their systems such as hybrid or parallel robots where inverse kinematics calculation cannot be solved by using regular approaches described in the beginning of this chapter. In order to select this method, as usual with other methods, solver type should be set to ‘User inverse’. When Advanced is clicked, the extra tabs Configurations and Actuator Space Map are the same as with other methods. On the other hand, Solver Attributes tab display differences. The differences can be seen in figure 31. The first section in this tab is ‘Link Parameters’. These parameters are used as input to C-code file to be utilized in the calculation. The ‘Auxiliary Data’ section also has the same properties as ‘Link Parameters’. The third section is ‘Define Library and Routine Names’, which is where the user enters the name of the C-file as routine name and the library file created by compiling the code. Figure 30: Device Specific method and Solver Attributes tab Figure 31: User inverse method and Solver Attributes tab 23 In the next section, the structure of the C-file will be presented along with how to compile it for the use of DELMIA V5. Also this part will be covered in the appendix as how-to type documentation. 3.3.2. THE ANALYSIS OF C-FILE FOR INVERSE KINEMATICS IN DELMIA V5 In this section, the C-file structure will be analyzed. This analysis will not include any calculation or specific name but only kin_example. This name is chosen in order for a layman user to grasp the mechanics of C-file creation for DELMIA V5. The C-code for inverse kinematics starts with a #include command. The shlibdefs.h file is a standard library for DELMIA V5 that has the standard macros and structures that are used in the creation of the inverse kinematics such as math operations. #define NUM_SOLUTIONS 1 /* Number of possible solutions */ #define NUM_DOFS 6 /* Number of joints to be solved */ These 2 lines of commands define the number of solutions achieved after solving the inverse kinematics (which also defines the number of possible postures a robot can perform for a given TCP) and degrees of freedom with command that the investigated mechanism has. The NUM_SOLUTIONS variable also defines the number of columns for the solution array, which will be shown later. The number of solutions and DOFs are determined by the robot type used and for example, a hexapod has six degrees of freedom with command and one possible solution for given TCP values. In the following lines, the routines describe the interaction of the C-file with DELMIA V5. This interaction requires some change with respect to the name used for the C-file. DllExport int get_kin_config( char *kin_routine, int *kin_dof, int *solution_count, int *usrKinDataHint ) { if( strcmp( kin_routine, "kin_example" ) == 0 ) { *kin_dof = NUM_DOFS; *solution_count = NUM_SOLUTIONS; /* * this indicates kin_usr's last argument (void *pData) * will be DLM_Data_KinStat */ *usrKinDataHint = USR_KIN_DATA_KINSTAT; return 0; } return 1; } 24 static char JointType[2][24] = { "ROTATIONAL", "TRANSLATIONAL" }; static char KinMode[2][24] = { "Normal", "TrackTCP" }; In the following line, the user needs to state the name of C-file for strcmp command which compares the name of 2 strings and return 0 if the 2 strings match each other. /* * User must supply this function */ DllExport int get_kin_config( char *kin_routine, int *kin_dof, int *solution_count, int *usrKinDataHint ) { if( strcmp( kin_routine, "kin_example" ) == 0 ) { *kin_dof = NUM_DOFS; *solution_count = NUM_SOLUTIONS; /* * this indicates kin_usr's last argument (void *pData) * will be DLM_Data_KinStat */ *usrKinDataHint = USR_KIN_DATA_KINSTAT; return 0; } return 1; } static char JointType[2][24] = { "ROTATIONAL", "TRANSLATIONAL" }; static char KinMode[2][24] = { "Normal", "TrackTCP" }; In this case, the name "kin_example" is the name of the C-file and it is stated in the strcmp command. The following piece of code is utilized by DELMIA V5 to recognize the function named same as the C-file with variables which are input from DELMIA V5 to C-file. ‘T6’ here is the transformation matrix. ‘link_lengths’ is the distance between joint axes along the link lengths where “link offsets” is the shortest distance between joint axes – which are described in the previous section. These values according to DELMIA V5 are associated with the methodology called Denavitt-Hartenberg method (Hartenberg 1967). /* ** Routine Name */ DllExport int kin_hexapodFullTest( link_lengths, link_offsets, T6, /* See above for description of these arguments */ solutions, warnings, pData ) /* 25 ** Passed Variable Declarations */ double T6[4][4], link_lengths[], link_offsets[], solutions[][NUM_SOLUTIONS]; int warnings[]; For the lines above, a special attention should be given to the transformation matrix T6. As the name suggests, T6 is the result of successive multiplication of serial transformations, which are 3 translations in x, y and z direction, following 3 rotations about Z, Y and X-axes. Unlike, the traditional calculation of the transformation matrix for an articulated robot, T6 here is the direct transformation between the world coordinates attached or Base Reference depending on the choice of the user and the TCP.Thus, the transformation matrix as an input from DELMIA V5 has the form in figure 32.              1 0 0 0 6 pzpypx azayax ozoyox nznynx T In this T6 matrix, the notations n(xyz), o(xyz) and a(xyz) represent the axes of the TCP. It must be noted that the representation of these axes have the row-vector form. Thus, when calculating the correct form of multiplication must be used. The p(xyz) notation describes the translation of a transformation matrix in X,Y and Z-axes with respect to the chosen coordinate frame as reference. In the following piece of code, pData routine is defined. This routine is created as standard by DELMIA V5 in order for users to define their inverse kinematics; thus, pData routine is the main function for users. As seen below, the routine starts with the local variable declarations that are the constituting terms of the transformation matrix. The users are also entitled to add variables as they see fit for their calculation. void *pData; /* usr routine should NEVER delete pData */ { /* ** Local Variable Declarations (add variable declarations as appropriate) */ long double nx, ny, nz, ox, oy, oz, ax, ay, az, px, py, pz; Figure 32: T6 matrix of DELMIA V5 26 After variable declaration, DELMIA V5 inserts a standard if-loop to print mechanism properties and its current joint values for a given TCP. This part is essential for debugging purposes since these values are taken from ‘Jog Mechanism’ window directly. This loop can be seen below. #if 1 /* * using pData */ int i; DLM_Data_KinStat *pDLM_Data = (DLM_Data_KinStat *) pData; if( pDLM_Data ) { printf( "\n\ndof_count: %d\n", pDLM_Data->dof_count ); printf( "\njoint_types:\n" ); for( i = 0; i < pDLM_Data->dof_count; i++ ) printf( "%s ", JointType[(pDLM_Data->joint_types)[i]] ); printf( "\n\nkin_mode: %s\n", KinMode[pDLM_Data->kin_mode] ); printf( "\njoint_values:\n" ); for( i = 0; i < pDLM_Data->dof_count; i++ ) printf( "%12.4f ", pDLM_Data->joint_values[i] ); printf( "\n\njnt_trvl_lmts lower:\n" ); for( i = 0; i < pDLM_Data->dof_count; i++ ) printf( "%12.4f ", pDLM_Data->jnt_trvl_lmts[0][i] ); printf( "\n\njnt_trvl_lmts upper:\n" ); for( i = 0; i < pDLM_Data->dof_count; i++ ) printf( "%12.4f ", pDLM_Data->jnt_trvl_lmts[1][i] ); printf( "\n\n" ); } #endif The next section in the C-file is that DELMIA V5 declares that the users should start their calculation after this given point. The declaration is /***--------------- Execution Begins Here ---------------------------------- ***/ /* ** DO NOT REMOVE THIS BLOCK OF CODE ** IT IS REQUIRED TO PROPERLY SET THE NUMBER OF KINEMATIC ** DOFS FOR THE DEVICE */ if( !kin_check_definition( NUM_DOFS, NUM_SOLUTIONS ) ) { /* ** Inconsistency between device definition and inverse ** kinematics routine exists. A warning message has been ** issued and routine aborted */ return( 1 ); } /***---------------- User code begins here --------------------------------- ***/ 27 After the necessary calculations are made, the user needs to feed DELMIA V5 back with the joint values. This is achieved by using an array called solutions[][NUM_SOLUTIONS]. An example of such action is given below. solutions[0][0] = J1; solutions[1][0] = J2; solutions[2][0] = J3; solutions[3][0] = J4; solutions[4][0] = J5; solutions[5][0] = J6; The lines above appoint values to the elements of an array, where these values are named as J1, J2, etc. These elements belong to the current values of joints, in this case the six joints of a respective mechanism. Next important aspect is that the users are also entitled to print any value on debugging window. This action can be delivered with a line, for example printf( "J1 J2 J3: %12.4f ,%12.4f ,%12.4f\n", J1 ,J2 ,J3 ); printf( "J4 J5 J6: %12.4f ,%12.4f ,%12.4f\n", J4 ,J5 ,J6 ); After having finished calculations, the user also must supply the following line to inform DELMIA V5 that the results end in an accepted posture for the mechanism. This is done by feeding back the warnings array. warnings[ 0 ] = WARN_GOOD_SOLUTION; return (0); } /* End of kin_example */ With the above lines, the user ends the creation of C-file and proceeds to compile the file for the creation of the required library files. 3.3.3. COMPILATION OF C-FILES The compilation process of C-files is somewhat delicate; but once it is completed, the process itself becomes easy to repeat. Before, going deep it must be noted that a compilation tool is necessary for this operation. In this thesis work, Microsoft Visual Studio 8 is used as compilation tool. The compatibility of other tools has not been tested. Thus, the approved and recommended tool is Microsoft’s Visual Studio (version of this program should no longer be earlier than VS 8). If another compiler has been chosen, it is important that the compilation tool must support C# language and has nmake feature available as a compilation operation is done via ‘nmake all’ command. Another important point regarding compilation process is about the operating system (OS) of the computer on which the simulation is going to be executed. If the system is 64-bit, users should implement a prerequisite operation before compilation. This operation will be covered in the appendix section as environment set-up. The reason to include this step in the appendix (APPENDIX F: COMPILATION OF C-FILES) is that it would be easier for layman users to follow a how-to type document. 28 4. THEORY OF INVERSE KINEMATICS FOR RESPECTIVE ROBOTS In this chapter, the inverse kinematics for hexapod/Flexapod 6P, Exechon and Gantry-Tau robots will be given. Also, the transfer of the theory to C-file will be presented at the end of the theory for each robot. 4.1. HEXAPOD/FLEXAPOD 6P INVERSE KINEMATICS The idea behind the inverse kinematics for hexapods is somewhat simple. The method relies on vector summation and with a known TCP position and orientation the leg lengths can be calculated as vectors and normalized to reach the total length. As presented earlier, a hexapod system has the kinematics chain of RR:P:RRR for one leg which specifically stands for revolute-revolute-prismatic-revolute-revolute-revolute (Ji 2001). This chain is illustrated in figure 33. In any theoretical representation, it is important to first clarify the notation used for the inverse calculation. To start with, two different coordinate frames will be appointed. The first one XYZ0 will be attached to the base platform that will be the fixed part of hexapod. The second frame XYZ6 will be at the center of mobile platform. The first set of vectors Lib will be utilized to describe the position of attachment points of legs from the base platform. The second set of vectors Li will describe the legs and the last set of vectors LitToTCP will illustrate legs’ upper attachment points with respect to the mobile platform’s coordinate frame XYZ6. The last vector is the position vector of the mobile platform notated as PXYZ. These vectors are shown in figure 34. With the vectors at hand, the following summation can be formulated (Yang 1998). (3.1) Base Mobile platform R R R P R R Figure 33: Hexapod/Flexapod kinematic chain of one leg 29 What equation 3.1 aims is that it describes the L1tToTCP vector in the base coordinates XYZ0 by multiplying it with the rotation matrix. Then by adding the translation vector PXYZ, It reaches to the upper attachment point. By subtracting L1b from the summation, the result becomes the vector between lower attachment point and the upper one, which is the vector Li. (Yang 1998). Then, to reach the total length of the leg normalization of the vector should be done by (3.2) Before transferring the theory to a C-file, it is important to give the coordinates of the vectors defined earlier. These vectors are constant and Lib is defined with respect to XYZ0 whereas LitToTCP is defined with respect to XYZ6. These vectors and their coordinates are given in table 1 and table 2for Hexapod and Flexapod 6P. XYZ0 Base X6 Z6 LitToTCP XYZ6 Mobile platform X0 Z0 Lib Li Figure 34: Hexapod and the constituting vectors 30 HEXAPOD Lower Attachment Points Lib Upper Attachment Points LitToTCP Coordinates Leg 1 Leg 2 Leg 3 Leg 4 Leg 5 Leg 6 Leg 1 Leg 2 Leg 3 Leg 4 Leg 5 Leg 6 X-coordinate 31 -31 -117.826 -86.826 86.826 117.826 31 - 31 -57.761 -26.761 26.761 57.761 Y-coordinate 118.156 118.156 -32.231 -85.925 -85.925 -32.231 48.799 48.799 2.447 -51.246 -51.246 2.447 Z-coordinate 40.205 40.205 40.205 40.205 40.205 40.205 -31.45 -31.45 -31.45 -31.45 -31.45 -31.45 Table 1: Coordinates of vectors for hexapod FLEXAPOD 6P Lower Attachment Points Lib Upper Attachment Points LitToTCP Coordinates Leg 1 Leg 2 Leg 3 Leg 4 Leg 5 Leg 6 Leg 1 Leg 2 Leg 3 Leg 4 Leg 5 Leg 6 X-coordinate -132.5 43.733 88.767 88.767 43.733 -132.5 -48.767 -3.733 52.5 52.5 -3.733 -48.767 Y-coordinate 26 127.748 101.748 -101.748 -127.748 -26 32.466 58.466 26 -26 -58.466 -32.466 Z-coordinate 58.5 58.5 58.5 58.5 58.5 58.5 -75 -75 -75 -75 -75 -75 Table 2: Coordinates of vectors for Flexapod 6P 31 4.2. HEXAPOD/FLEXAPOD 6P – TRANSFER OF THEORY TO A C-FILE In this section, the theory presented in 4.1 will be transferred to the C-file. Only the theory and calculations will be described and complete C-file can be seen in appendix. The calculation starts with, as stated in 3.3.2, the necessary declarations for variables. These variables are the elements of the transformation matrix, leg lengths and legs upper attachment coordinates. The corresponding notation, then,  Transformation matrix: nx, ny, nz, ox, oy, oz, ax, ay, az, px, py, pz  Total leg lengths: L1, L2, L3, L4, L5, L6  Coordinates: o Leg 1: D11 in X-axis, D12 in Y-axis, D13 in Z-axis o Leg 2: D21 in X-axis, D22 in Y-axis, D23 in Z-axis o Leg 3: D31 in X-axis, D32 in Y-axis, D33 in Z-axis o Leg 4: D41 in X-axis, D42 in Y-axis, D43 in Z-axis o Leg 5: D51 in X-axis, D52 in Y-axis, D53 in Z-axis o Leg 6: D61 in X-axis, D62 in Y-axis, D63 in Z-axis  Joint values: J1, J2, J3, J4, J5, J6  Leg length when joint command is zero: Lref  Vectors: o Vectors that connect mobile platform’s coordinate frame to upper attachment points  L1tToTCP[4][1]  L2tToTCP[4][1]  L3tToTCP[4][1]  L4tToTCP[4][1]  L5tToTCP[4][1]  L6tToTCP[4][1] o Vectors that connect base platform to lower attachment points  L1b[4][1]  L2b[4][1]  L3b[4][1]  L4b[4][1]  L5b[4][1]  L6b[4][1] o Intermediary vector definition that is the result of the summation between  L1tCur[4]  L2tCur[4]  L3tCur[4]  L4tCur[4]  L5tCur[4] 32  L6tCur[4] o Array declaration for the arranged transformation matrix which is in column vector form  TCP[4][4] o Additional variables to perform matrix multiplication  inner1, inner2, inner3, inner4, inner5, inner6  row1, row2, row3, row4, row5, row6  col1, col2, col3, col4, col5, col6 These declarations in the code should be as void *pData; /* usr routine should NEVER delete pData */ { /* ** Local Variable Declarations (add variable declarations as appropriate) */ long double nx, ny, nz, ox, oy, oz, ax, ay, az, px, py, pz; long double D11, D12, D13, D21, D22, D23, D31, D32, D33, D41, D42, D43, D51, D52, D53, D61, D62, D63; long double L1,L2,L3,L4,L5,L6,J1,J2,J3,J4,J5,J6, Lref; //Variables to perform matrix multiplication int row1,row2,row3,row4,row5,row6; int col1,col2,col3,col4,col5,col6; int inner1,inner2,inner3,inner4,inner5,inner6; // The upper attachmentpoints for each leg (The vector between the TCP and each upper attachment point). long double L1tToTCP[4][1]; long double L2tToTCP[4][1]; long double L3tToTCP[4][1]; long double L4tToTCP[4][1]; long double L5tToTCP[4][1]; long double L6tToTCP[4][1]; //The transformed T6 matrix named as TCP matrix (do not confuse with Tool Centre Point) - see line 307. long double TCP[4][4]; //The current position for each upper attachmentpoint (in Base coordinates). long double L1tCur[4] = {0}; long double L2tCur[4] = {0}; long double L3tCur[4] = {0}; long double L4tCur[4] = {0}; long double L5tCur[4] = {0}; long double L6tCur[4] = {0}; //Lower attachemnt points on each leg (in Base coordinates) long double L1b[3]; long double L2b[3]; long double L3b[3]; long double L4b[3]; long double L5b[3]; long double L6b[3]; 33 After the declarations, matrix elements should be appointed to T6 matrix – which is, as said earlier, standard definition and input of DELMIA V5 to describe the transformation between two coordinate frames. This operation is done by //Importing the current TCP values from Delmia through the T6 matrix and putting proper context nx = T6[0][0]; ny = T6[0][1]; nz = T6[0][2]; ox = T6[1][0]; oy = T6[1][1]; oz = T6[1][2]; ax = T6[2][0]; ay = T6[2][1]; az = T6[2][2]; px = T6[3][0]; py = T6[3][1]; pz = T6[3][2]; In order to perform the matrix multiplication, the transformation matrix should be rearranged in column vector format. This operation can be skipped and the rest of the calculation can be done accordingly with the row vector form; however, for this thesis work column vector form is chosen. So this arrangement is done via //The transforming T6 matrix from row vectors form to column vector form TCP[0][0] = nx; TCP[0][1] = ox; TCP[0][2] = ax; TCP[0][3] = px; TCP[1][0] = ny; TCP[1][1] = oy; TCP[1][2] = ay; TCP[1][3] = py; TCP[2][0] = nz; TCP[2][1] = oz; TCP[2][2] = az; TCP[2][3] = pz; TCP[3][0] = 0; TCP[3][1] = 0; TCP[3][2] = 0; TCP[3][3] = 1; At this point, by measuring the coordinates of upper and lower attachment points in hexapod when all the actuators are zero, LitToTCP and Lib vectors can be defined with actual vector values. Thus the corresponding values are declared as //The vector between the TCP and the upper attachmentpoints for each leg L1tToTCP[0][0] = 31; L1tToTCP[1][0] = 48.799; L1tToTCP[2][0] = -31.45; L1tToTCP[3][0] = 1; L2tToTCP[0][0] = -31; L2tToTCP[1][0] = 48.799; L2tToTCP[2][0] = -31.45; L2tToTCP[3][0] = 1; L3tToTCP[0][0] = -57.761; L3tToTCP[1][0] = 2.447; L3tToTCP[2][0] = -31.45; L3tToTCP[3][0] = 1; L4tToTCP[0][0] = -26.761; L4tToTCP[1][0] = -51.246; L4tToTCP[2][0] = -31.45; L4tToTCP[3][0] = 1; L5tToTCP[0][0] = 26.761; L5tToTCP[1][0] = -51.246; L5tToTCP[2][0] = -31.45; L5tToTCP[3][0] = 1; L6tToTCP[0][0] = 57.761; L6tToTCP[1][0] = 2.447; L6tToTCP[2][0] = -31.45; L6tToTCP[3][0] = 1; //The lower attachmentpoints for each leg (in Base-coordinates). L1b[0] = 31; L1b[1] = 118.156; L1b[2] = 40.205; L2b[0] =-31; L2b[1] = 118.156; L2b[2] = 40.205; L3b[0] =-117.826; L3b[1] = -32.231; L3b[2] = 40.205; L4b[0] =-86.826; L4b[1] = -85.925; L4b[2] = 40.205; L5b[0] = 86.826; L5b[1] = -85.925; L5b[2] = 40.205; 34 L6b[0] = 117.826; L6b[1] = -32.231; L6b[2] = 40.205; Lref = 376.5; Since the coordinates are appointed to the vectors, equation 3.1 can be executed. Thus the multiplication and summation is done with for six legs where R matrix is TCP //Calculating the current position (in x,y,z in Base coordinates) of each upper attachment point for each leg by multiplying the transformation // matrix TCP[4][4] with the vector between the current TCP (the T6 matrix) and the upper attachmentpoint for each leg (LxToTCP[][]) //Calculate upper position on Leg1 (The array L1tCur) for (row1 = 0; row1 < 4; row1++) { for (col1 = 0; col1 < 1; col1++) { // Multiply the row of A by the column of B to get the row, column of product. for (inner1 = 0; inner1 < 4; inner1++) { L1tCur[row1] += TCP[row1][inner1] * L1tToTCP[inner1][col1]; } } } //Calculate upper position on Leg2 (The array L2tCur) for (row2 = 0; row2 < 4; row2++) { for (col2 = 0; col2 < 1; col2++) { // Multiply the row of A by the column of B to get the row, column of product. for (inner2 = 0; inner2 < 4; inner2++) { L2tCur[row2] += TCP[row2][inner2] * L2tToTCP[inner2][col2]; } } } //Calculate upper position on Leg3 (The array L3tCur) for (row3 = 0; row3 < 4; row3++) { for (col3 = 0; col3 < 1; col3++) { // Multiply the row of A by the column of B to get the row, column of product. for (inner3 = 0; inner3 < 4; inner3++) { L3tCur[row3] += TCP[row3][inner3] * L3tToTCP[inner3][col3]; } } } //Calculate upper position on Leg4 (The array L4tCur) for (row4 = 0; row4 < 4; row4++) { for (col4 = 0; col4 < 1; col4++) { // Multiply the row of A by the column of B to get the row, column of product. for (inner4 = 0; inner4 < 4; inner4++) { L4tCur[row4] += TCP[row4][inner4] * L4tToTCP[inner4][col4]; } } } 35 //Calculate upper position on Leg5 (The array L5tCur) for (row5 = 0; row5 < 4; row5++) { for (col5 = 0; col5 < 1; col5++) { // Multiply the row of A by the column of B to get the row, column of product. for (inner5 = 0; inner5 < 4; inner5++) { L5tCur[row5] += TCP[row5][inner5] * L5tToTCP[inner5][col5]; } } } //Calculate upper position on Leg6 (The array L6tCur) for (row6 = 0; row6 < 4; row6++) { for (col6 = 0; col6 < 1; col6++) { // Multiply the row of A by the column of B to get the row, column of product. for (inner6 = 0; inner6 < 4; inner6++) { L6tCur[row6] += TCP[row6][inner6] * L6tToTCP[inner6][col6]; } } } The result of this operation is LitCur. Since the transformation matrix is 4x4 in which translation vector is included, the summation operation is automatically done as the multiplication operation continues. So LitCur is then (3.3) Then, the subtraction operation will be done. With the result of the subtraction operation in hand, it is instantly normalized by adding the squares of vector components of the resulting vector. This is achieved via // Calcultates the distance between the upper and lower attachment points for each leg. L1 = sqrt(((pow((L1tCur[0]-L1b[0]),2)))+((pow((L1tCur[1]- L1b[1]),2)))+((pow((L1tCur[2]-L1b[2]),2)))); L2 = sqrt(((pow((L2tCur[0]-L2b[0]),2)))+((pow((L2tCur[1]- L2b[1]),2)))+((pow((L2tCur[2]-L2b[2]),2)))); L3 = sqrt(((pow((L3tCur[0]-L3b[0]),2)))+((pow((L3tCur[1]- L3b[1]),2)))+((pow((L3tCur[2]-L3b[2]),2)))); L4 = sqrt(((pow((L4tCur[0]-L4b[0]),2)))+((pow((L4tCur[1]- L4b[1]),2)))+((pow((L4tCur[2]-L4b[2]),2)))); L5 = sqrt(((pow((L5tCur[0]-L5b[0]),2)))+((pow((L5tCur[1]- L5b[1]),2)))+((pow((L5tCur[2]-L5b[2]),2)))); L6 = sqrt(((pow((L6tCur[0]-L6b[0]),2)))+((pow((L6tCur[1]- L6b[1]),2)))+((pow((L6tCur[2]-L6b[2]),2)))); 36 Then from total leg lengths, the reference length (notated as Lref) – which is the total length when joint command is zero – will be subtracted. This way, joint values will be achieved and these values J1, J2, J3, J4, J5 and J6 will be fed back to ‘solutions’ array. This is accomplished by //Calculates the joint values by calulating the differnce in distance between the two attachmentpoints on each leg and a reference length (Lref) //(the lenght between attachment points when the joints are 0) J1 = L1 - Lref; J2 = L2 - Lref; J3 = L3 - Lref; J4 = L4 - Lref; J5 = L5 - Lref; J6 = L6 - Lref; D11 = L1tCur[0]; D12 = L1tCur[1]; D13 = L1tCur[2]; D21 = L2tCur[0]; D22 = L2tCur[1]; D23 = L2tCur[2]; D31 = L3tCur[0]; D32 = L3tCur[1]; D33 = L3tCur[2]; D41 = L4tCur[0]; D42 = L4tCur[1]; D43 = L4tCur[2]; D51 = L5tCur[0]; D52 = L5tCur[1]; D53 = L5tCur[2]; D61 = L6tCur[0]; D62 = L6tCur[1]; D63 = L6tCur[2]; //Sending the final joint values back to the "solutions"-matrix which is the input matrix for Delmia. solutions[0][0] = J1; solutions[1][0] = J2; solutions[2][0] = J3; solutions[3][0] = J4; solutions[4][0] = J5; solutions[5][0] = J6; With the lines above, the calculation phase is accomplished. After this point, the user can also print any value on debugging window in order to verify that the inverse kinematics is working. Such printing operation, in this case, can be done for leg lengths and their corresponding coordinates with //Printing some of the variable values out in the debug window to ease debugging and get an overview of what is going on printf( "\n The leg lengths\n" ); printf( "J1 J2 J3: %12.4f ,%12.4f ,%12.4f\n", J1 ,J2 ,J3 ); printf( "J4 J5 J6: %12.4f ,%12.4f ,%12.4f\n", J4 ,J5 ,J6 ); printf( "L1 L2 L3: %12.4f ,%12.4f ,%12.4f\n", L1 ,L2 ,L3 ); printf( "L4 L5 L6: %12.4f ,%12.4f ,%12.4f\n", L4 ,L5 ,L6); printf( "\n The legs' upper attachment point coordinates \n" ); printf( "\D11 D12 D13: %12.4f ,%12.4f ,%12.4f\n", D11 ,D12 ,D13 ); printf( "\D21 D22 D23: %12.4f ,%12.4f ,%12.4f\n", D21 ,D22 ,D23 ); printf( "\D31 D32 D33: %12.4f ,%12.4f ,%12.4f\n", D31 ,D32 ,D33 ); printf( "\D41 D42 D43: %12.4f ,%12.4f ,%12.4f\n", D41 ,D42 ,D43 ); printf( "\D51 D52 D53: %12.4f ,%12.4f ,%12.4f\n", D51 ,D52 ,D53 ); printf( "\D61 D62 D63: %12.4f ,%12.4f ,%12.4f\n", D61 ,D62 ,D63 ); After printing values the code continues with the declaration of an acceptable solution via warnings[ 0 ] = WARN_GOOD_SOLUTION; 37 And the C-file is terminated with return (0); } With termination, the transfer of the theory is completed. It must be noted that the coordinates used in this code belong to hexapod. For Flexapod 6P case, the corresponding lines can be altered according to values in Table 2. 38 4.3. EXECHON INVERSE KINEMATICS – THEORY The inverse kinematics theory of Exechon has been presented in literature in various ways. One of those ways is presented by Bi (2011). In the respective theory, inverse kinematics is treated by using intermediate variables defining the position and orientation of the mobile platform; and through these variables, the coordinates of the attachment points are calculated. Zoppi (2010) is also adopting a similar way where the inverse kinematics approach is defined via intermediate variables that are not defining the direct value of the joints. Thus, a parallel theory employed for Stewart platforms can be applied to Exechon. The idea of this similar inverse kinematics is that with a transformation matrix, the vectors that connect mobile platform to legs’ lower attachment points can be described with respect to base coordinate frame, which is done by multiplication of these vectors with a T6 matrix. Then, the constant vectors that connect the base coordinate frame to fixed upper attachment points – which are the centers of RR-joints for identical legs and spherical joint for the perpendicular leg – are subtracted from the product of the multiplication operation. Then, the resulting vectors that define the legs are normalized and the standard leg lengths when the actuators are zero are subtracted from the normalized vectors – which results in the joint values under actuation (Bi 2011). L2b L3b L3tToTCP XYZ6 XYZ0 L1b L1tToTCP L2tToTCP L1 L2 L3 Figure 35: The vector description of Exechon robot's parallel structure Mobile Platform 39 In order to clarify the calculations, the vectors need to be illustrated with their notations. These vectors are shown in figure 35. Then, the theory of inverse kinematics for the parallel part of Exechon will be presented. The necessary vectors and the coordinate frames are then  XYZ0 – Base coordinate system  XYZ6 – Mobile platform’s coordinate system located at the center of a possible wrist  Li – The set of vectors to define the corresponding leg’s position and orientation.  Lib – The constant vectors that define the location of upper attachment points of legs  LitToTCP – The set of vectors that connect XYZ6 to attachment points on mobile platform As put earlier, the methodology is somewhat similar to hexapod; and that is the reason same notation is used for this robot as well. First step in the calculation is to describe LitToTCP vectors in the base coordinate system (Bi 2011). To achieve that, the use of transformation matrix T6 – which is input from DELMIA V5 – is required. The transformation matrix for this robot will be measuring the coordinate frame XYZ6’s orientation and position. Thus, description of the mobile platform’s vectors in base coordinate frame is (3.4) Then, since transformation matrix includes translation the result of equation 3.4 is now equal to the summation of Lib and Li. When Lib is subtracted, the result will be the vector describing Li (Bi 2011). Hence, (3.5) (3.6) Finally, the normalization of this vector will yield the total length, which is (3.7) In the case of Exechon as with hexapod, the reference length must be subtracted from the product of equation 3.7 so that the result of subtraction can be fed back to solutions matrix of the C-code. This part is not described in the theory section for it is defined when the assembly is completed in DELMIA V5. However, it must be noted that the reference lengths of Exechon robot may differ from each other depending on the CAD-models. These lengths in this thesis work are 803.887 mm for identical legs and 886.021 mm for leg 3. As in the case of hexapod, these constant vectors should be defined and these values for the coordinates of the respective vectors are given in table 3. 40 HEXAPOD From Base Coordinate System to Upper Attachment Points Lib Mobile Platform’s Lower Attachment Points LitToTCP Coordinates Leg 1 Leg 2 Leg 3 Leg 1 Leg 2 Leg 3 X-coordinate 420 -420 0 173 -173 0 Y-coordinate 0 0 670 -50 -50 173 Z-coordinate 0 0 0 485 485 485 Table 3: Coordinates for the vectors of Exechon 4.4. THEORY OF EXECHON TO C-FILE As with the case of Flexapod 6P and hexapod cases, the c-file starts with declarations of coordinates. These coordinates and corresponding vectors are declared as //The vector between the TCP and the upper attachmentpoints for each leg L1tToTCP[0][0] = 173; L1tToTCP[1][0] = -50; L1tToTCP[2][0] = 485; L1tToTCP[3][0] = 1; L2tToTCP[0][0] = -173; L2tToTCP[1][0] = -50; L2tToTCP[2][0] = 485; L2tToTCP[3][0] = 1; L3tToTCP[0][0] = 0; L3tToTCP[1][0] = 173; L3tToTCP[2][0] = 485; L3tToTCP[3][0] = 1; //The lower attachmentpoints for each leg (in Base-coordinates). L1b[0] = 420; L1b[1] = 0; L1b[2] = 0; L2b[0] = -420; L2b[1] = 0; L2b[2] = 0; L3b[0] = 0; L3b[1] = 670; L3b[2] = 0; Then, the calculations start with transforming or in other words describing LitToTCP vectors in base coordinate system by using a matrix multiplication function for three LitToTCP vectors. //Calculate upper position on Leg1 (The array L1tCur) for (row1 = 0; row1 < 4; row1++) { for (col1 = 0; col1 < 1; col1++) { // Multiply the row of A by the column of B to get the row, column of product. for (inner1 = 0; inner1 < 4; inner1++) { L1tCur[row1] += TCP[row1][inner1] * L1tToTCP[inner1][col1]; } } } //Calculate upper position on Leg2 (The array L2tCur) for (row2 = 0; row2 < 4; row2++) { for (col2 = 0; col2 < 1; col2++) { 41 // Multiply the row of A by the column of B to get the row, column of product. for (inner2 = 0; inner2 < 4; inner2++) { L2tCur[row2] += TCP[row2][inner2] * L2tToTCP[inner2][col2]; } } } //Calculate upper position on Leg3 (The array L3tCur) for (row3 = 0; row3 < 4; row3++) { for (col3 = 0; col3 < 1; col3++) { // Multiply the row of A by the column of B to get the row, column of product. for (inner3 = 0; inner3 < 4; inner3++) { L3tCur[row3] += TCP[row3][inner3] * L3tToTCP[inner3][col3]; } } } Then, from LitToTCP vectors the base vectors Lib will be subtracted and the product of this operation will be normalized. This operation is done via // Calcultates the distance between the upper and lower attachment points for each leg. L1 = sqrt(((pow((L1tCur[0]-L1b[0]),2)))+((pow((L1tCur[1]- L1b[1]),2)))+((pow((L1tCur[2]-L1b[2]),2)))); L2 = sqrt(((pow((L2tCur[0]-L2b[0]),2)))+((pow((L2tCur[1]- L2b[1]),2)))+((pow((L2tCur[2]-L2b[2]),2)))); L3 = sqrt(((pow((L3tCur[0]-L3b[0]),2)))+((pow((L3tCur[1]- L3b[1]),2)))+((pow((L3tCur[2]-L3b[2]),2)))); From this total length, the reference length of for identical legs and leg 3 will be subtracted and the result will be fed back to solutions matrix. //The distance between upper and lower leg attachmentpoint when the command joint is zero. Used as a reference to get the current leg length Lref12 = 803.887; Lref3 = 886.021; //Calculates the joint values by calulating the differnce in distance between the two attachmentpoints on each leg and a reference length (Lref) //(the lenght between attachment points when the joints are 0) J1 = L1 - Lref12; J2 = L2 - Lref12; J3 = L3 - Lref3; //Sending the final joint values back to the "solutions"-matrix which is the input matrix for Delmia. solutions[0][0] = J1; solutions[1][0] = J2; solutions[2][0] = J3; 42 4.5. GANTRY-TAU ROBOT The inverse kinematics aspect of Gantry-Tau robots bears some similarities to previous robots of this thesis work since it is comprised of a parallel structure. The schematic description of this robot can be seen in figure 36. In order to develop the inverse kinematics, the kinematic description of Gantry-Tau is essential. Each link in the clusters have the kinematic chain of prismatic joint with actuation, universal joint and a spherical joint that connects the link to the mobile platform. Therefore, from the inverse kinematics perspective, the outcome of calculations should yield values for prismatic actuators Pi (i = 1-3). To find these joint values, then, each cluster will be analyzed separately; and in each cluster, one link and its constituting vectors will be used due to parallel formation of the mechanism (Johannesson 2003). l1 l2 l3 Z X Y Figure 36: Gantry-Tau robot Prismatic(P1) Prismatic(P2) Prismatic (P3) Cluster 1 (C1) Cluster 2 (C2) Cluster 3 (C3) 43 In figure 37, the vectors that constitute link 1’s kinematic chain can be seen. From these vectors, it is possible to develop the equation 3.8 for link 1 (3.8) (3.9) where is the transformation matrix between the TCP and base frame whereas is the rotational part of . Since is a constant length in the mechanism as well as and , the actuators coordinate’s coordinates can easily be found (Johannesson 2003). Let be equal to and equation 3.8 be arranged as (3.10) If the vectors and their components are rewritten in matrix form, then                                         1 d d d 1 0 0 P 1 N N N l z1, y1, x1,x1, z1, y1, x1, 1                  1 dN dN dPN l z1,z1, y1,y1, x1,x1,x1, 1 (3.11) Figure 37: Link 1's vector definition P1 TCP n1 l1 Z X Y d1 T 44 As put before, the lengths of the links are constant and known; thus, when the right hand side of equation 3.11 is normalized (3.12) Then, when the variable is separated (3.13) From equation 3.13, the actuator value has two solutions (Johannesson 2003). This chain of calculations will be repeated for the remaining prismatic actuators as well. The schematic description of the vectors that comprise link 3 is in figure 38. For the second actuator, the same type of calculation done for the first will be created. The sum of the vectors presented in figure 38 corresponds to (3.14) As in link 1, let the right hand side of equation 3.14 be and when the left hand side of the equation is separated and represented in matrix form TCP Z X Y S2 P2 d2 l2 T n2 Figure 38: Prismatic joint 2 and the corresponding vectors 45                                                      1 d d d 1 0 0 P 1 S S S 1 N N N l z2, y2, x2,x2, z2, y2, y2, z2, y2, x2, 2                  1 dSN dSN dP SN l z2,z2,z2, y2,y2,y2, x2,x2,x2,x2, 2 (3.15) When both hand sides of equation 3.15 are normalized, then (3.16) With separation of variables of equation 3.16, the prismatic joint value (3.17) As in earlier joint, two solutions exist for P2,X as well (Johannesson 2003). The last actuator is attached to the last link l6 in the robot. Thus the vectors that constitute this chain can be seen in figure 39. Repeating the same idea for other joints, the sum of the vectors for the last prismatic joint will yield (3.18) S3 Figure 39: Prismatic joint 3's vectors Z X Y TCP P3 d3 l3 T n3 46 Let the right hand side of equation 3.18 be and when the left hand side of the equation is separated and represented in matrix form                                                      11 0 0 P 1 S S S 1 N N N l 3, 3, x3,x3, 3, y3, 3, z,3 y,3 x,3 3 z y z x d d d                  1 SN SN PSN l z3,z3,z3, y3,y3,y3, x3,x3,x3,x3, 3 d d d (3.19) When both hand sides of equation 3.19 are normalized, then (3.20) With separation of variables of equation 3.16, the prismatic joint value is (3.21) The last joint has two solutions as well as the earlier joints. Thus, in total Gantry-Tau robot has eight different postures for given TCP values. The robot chooses the best configuration/posture in real-time applications whereas in DELMIA V5 users are allowed to specify the posture. Another important point to keep in mind is that the forward kinematics of Gantry-Tau robot also offers various postures for given joint values (Johannesson 2003). Since such situation cannot be defined in DELMIA V5, it is possible to have some errors when a change is made between the postures offered by inverse kinematics. This problem usually changes the coordinates TCP when the current posture is changed (for the forward kinematics calculation, refer to the appendix). Before proceeding to the creation of C-file, the necessary coordinates for Gantry-Tau is given in table 4. S1 S2 S3 d1 d2 d3 n1 n2 n3 X 0 -1100 -2200 -96.569 0 96.569 224.999 0 -182.574 Y 0 700 0 -185 -322.843 0 -240.001 39.705 -80 Z 0 0 0 -400 -173.726 -400 171.568 336.862 213.994 Table 4: Coordinates of the vectors for Gantry-Tau 47 4.6. THEORY OF GANTRY-TAU ROBOT TO C-FILE As with previous cases, the variables should be defined. These variables for the given vectors in Table 4 are defined as /***---------------- User code begins here --------------------------------- ***/ //The vectors to define the prismatic joints where Pi[2][0] is the prismatic joint value in negative direction P1[0][0] = 0; P1[1][0] = 0; P1[2][0] = 0; P1[3][0] = 1; P2[0][0] = -1100; P2[1][0] = 700; P2[2][0] = 0; P2[3][0] = 1; P3[0][0] = -2200; P3[1][0] = 0; P3[2][0] = 0; P3[3][0] = 1; //The constant vectors to define the upper attachment points from prismatic joint end d1[0][0] = -96.569; d1[1][0] = -185; d1[2][0] = -400; d1[3][0] = 1; d2[0][0] = 0; d2[1][0] = -322.843; d2[2][0] = -173.726; d2[3][0] = 1; d3[0][0] = 96.569; d3[1][0] = 0; d3[2][0] = -400; d3[3][0] = 1; //The vectors that connect TCP to lower attachment points. n1[0][0] = 224.999; n1[1][0] = -240.001;n1[2][0] = 171.568; n1[3][0] = 1; n2[0][0] = 0; n2[1][0] = 39.705; n2[2][0] = 336.862; n2[3][0] = 1; n3[0][0] = -182.574; n3[1][0] = -80; n3[2][0] = 213.994; n3[3][0] = 1; //Reference lengths Lref=1500 ; Lref2=1499.775; Again TCP matrix will be formed from T6 matrix as following //Importing the current TCP values from Delmia through the T6 matrix and putting proper context nx = T6[0][0]; ny = T6[0][1]; nz = T6[0][2]; ox = T6[1][0]; oy = T6[1][1]; oz = T6[1][2]; ax = T6[2][0]; ay = T6[2][1]; az = T6[2][2]; px = T6[3][0]; py = T6[3][1]; pz = T6[3][2]; //The transforming T6 matrix from row vectors form to column vector form TCP[0][0] = nx; TCP[0][1] = ox; TCP[0][2] = ax; TCP[0][3] = px; TCP[1][0] = ny; TCP[1][1] = oy; TCP[1][2] = ay; TCP[1][3] = py; TCP[2][0] = nz; TCP[2][1] = oz; TCP[2][2] = az; TCP[2][3] = pz; TCP[3][0] = 0; TCP[3][1] = 0; TCP[3][2] = 0; TCP[3][3] = 1; 48 Then, the multiplication of ni vectors with TCP matrix will be accomplished via //Calculating the current position (in x,y,z in Base coordinates) of each lower attachment point for each leg by multiplying the transformation // matrix TCP[4][4] with the vector between the current TCP (the T6 matrix) and the lower attachmentpoint for each leg //Calculate upper position on Leg1 (The array L1tCur) for (row1 = 0; row1 < 4; row1++) { for (col1 = 0; col1 < 1; col1++) { // Multiply the row of A by the column of B to get the row, column of product. for (inner1 = 0; inner1 < 4; inner1++) { NT1[row1][0] += TCP[row1][inner1] * n1[inner1][col1]; } } } //Calculate upper position on Leg2 (The array L2tCur) for (row2 = 0; row2 < 4; row2++) { for (col2 = 0; col2 < 1; col2++) { // Multiply the row of A by the column of B to get the row, column of product. for (inner2 = 0; inner2 < 4; inner2++) { NT2[row2][0] += TCP[row2][inner2] * n2[inner2][col2]; } } } //Calculate upper position on Leg3 (The array L3tCur) for (row3 = 0; row3 < 4; row3++) { for (col3 = 0; col3 < 1; col3++) { // Multiply the row of A by the column of B to get the row, column of product. for (inner3 = 0; inner3 < 4; inner3++) { NT3[row3][0] += TCP[row3][inner3] * n3[inner3][col3]; } } } Now, equations 3.13, 3.17, and 3.21 will be directly applied as following //Finding the joint values by using the theory. Multiplication with -1 stems from the direction of the joints. J11=-1*(NT1[2][0]-d1[2][0]+ sqrt(pow(Lref,2)-pow((P1[0][0]+d1[0][0]- NT1[0][0]),2)-pow((P1[1][0]+d1[1][0]-NT1[1][0]),2))); J12=-1*(NT1[2][0]-d1[2][0]- sqrt(pow(Lref,2)-pow((P1[0][0]+d1[0][0]- NT1[0][0]),2)-pow((P1[1][0]+d1[1][0]-NT1[1][0]),2))); J21=-1*(NT2[2][0]-d2[2][0]+ sqrt(pow(Lref,2)-pow((P2[0][0]+d2[0][0]- NT2[0][0]),2)-pow((P2[1][0]+d2[1][0]-NT2[1][0]),2))); J22=-1*(NT2[2][0]-d2[2][0]- sqrt(pow(Lref,2)-pow((P2[0][0]+d2[0][0]- NT2[0][0]),2)-pow((P2[1][0]+d2[1][0]-NT2[1][0]),2))); 49 J31=-1*(NT3[2][0]-d3[2][0]+ sqrt(pow(Lref2,2)-pow((P3[0][0]+d3[0][0]- NT3[0][0]),2)-pow((P3[1][0]+d3[1][0]-NT3[1][0]),2))); J32=-1*(NT3[2][0]-d3[2][0]- sqrt(pow(Lref2,2)-pow((P3[0][0]+d3[0][0]- NT3[0][0]),2)-pow((P3[1][0]+d3[1][0]-NT3[1][0]),2))); Then, the joint values are sent back to solutions matrix for all possible eight postures that can be created with J1, J2 and J3’s two different values. The matrix then should be as //Sending the final joint values back to the "solutions"-matrix which is the input matrix for Delmia. solutions[0][0] = J11; solutions[1][0] = J21; solutions[2][0] = J31; solutions[0][1] = J11; solutions[1][1] = J21; solutions[2][1] = J32; solutions[0][2] = J11; solutions[1][2] = J22; solutions[2][2] = J31; solutions[0][3] = J11; solutions[1][3] = J22; solutions[2][3] = J32; solutions[0][4] = J12; solutions[1][4] = J21; solutions[2][4] = J31; solutions[0][5] = J12; solutions[1][5] = J21; solutions[2][5] = J32; solutions[0][6] = J12; solutions[1][6] = J22; solutions[2][6] = J31; solutions[0][7] = J12; solutions[1][7] = J22; solutions[2][7] = J32; 50 5. RECOMMENDED COURSE OF ACTION FOR MECHANISM BUILDING IN DELMIA V5 – THE USER-FRIENDLY METHODOLOGY As the title suggests, this chapter is dedicated to describe the methodology employed to create a mechanism beyond the scope of technical knowledge required for any user to utilize DELMIA V5’s Device Building module. One of the most important aspects of mechanism building in the respective software is that any user can encounter various types of obstacles. Thus, in the preceding parts of this chapter each step of the designed methodology will be described. The first step of each device building project in DELMIA V5 is to first investigate the relative theory for inverse and forward kinematics of mechanism. By building this knowledge in advance, the users will not only learn about the inverse kinematics, but also be able to inherit the necessary understanding for the expected behavior of the target mechanism. The next step, as expected, is to create the forward kinematics of the mechanism in hand. Specifically, each mechanism may require a different approach than the next; however, the very basics of the mechanism building will still remain within the idea that first appoint the fixed part and successively build the mobile parts of the mechanism. When the end-effector is reached, the behavior of the mechanism should be checked via jogging the mechanism. Thus, the schematic methodology will look like for forward kinematics as in figure 40. After reaching a correct state in forward kinematics, the users now should analyze the inverse kinematics theory. The available literature may offer various ways to define inverse kinematics; however, since DELMIA V5 offers transformation matrix for the end-effector it would be important to apply the relevant theory with respect to such opportunity. After having defined the relative theory, users should also define the inverse kinematics parameters via the interface offered by DELMIA V5. This wizard/interface walks the users through the necessary parameters, which are well described in the appendices of this thesis work. Thirdly, it is highly-recommended for users to transfer the inverse kinematics theory to a MATLAB function as well, where users will be able to compare their simulation results to those coming from MATLAB. However, it is also important to verify MATLAB functions via using the created mechanism that has only forward kinematics definition. Users can verify these MATLAB functions by simply jogging the mechanism to a certain TCP position and orientation; and when these TCP values are applied to MATLAB, the outcome of the function should match the joint values in DELMIA V5. When these steps are collected and put in a scheme, the result will be as figure 41. Create the nod tree Bring in the parts of mechanism Create mechanism via new mechanism button Appoint the fixed part Successively create joints to reach the end- effector Control the behavior of the created mechanism Analyze inverse kinematics theory Apply and transform information with respect to DELMIA V5 Define inverse kinematics in DELMIA V5 interface Create MATLAB functions for the inverse kinematics Verify MATLAB functions Figure 40: Forward kinematics steps Figure 41: Inverse kinematics steps 51 After the parameter definition and verification of MATLAB functions, users are guided to create the C-file with analyzed and applied inverse kinematics description. Firstly, users should appo