Upload
others
View
1
Download
0
Embed Size (px)
Citation preview
Robot D-H Simulator Using Matlab Project
By Calvin Phillips
December 17, 2010
Introduction
A lot of simulators that have been made for robotic arms only show the simulation with
premade parameters. For this project I decided to create a robotic arm simulator that allows for the
creation of any type of robotic arm that has six joints or less. The robotic arms would be made using the
Denavit-Hartenberg (D-H) parameters for the robot. The simulator will allow for the joints of
robot to be revolute or prismatic. This allows for the user to create a simulator for an arm that
has or has not been made before. It allows for testing of robotic arm movements before they
are put into production.
In this paper I will talk about some of the background behind robotic arms. I will also talk
a little about the (D-H) approach to solving the kinematics of a robotic arm. Then, I will give
information about my approach to making the robotic simulator and why that approach was
chosen. With the approach, I will talk about why my method for creating the robot simulator
works. After that, the results will be shown to give my approach validity. In the end, I will wrap
up everything that I have done, and talk about what needs to be done in the future to make the
simulator more robust and efficient in simulating robotic arms for the user. Overall, I believe this
project to be a success, but there can always be improvements made to make the program run
better and more efficiently.
Technical Background
Robotic arms are programmable manipulators that have a lot of similarities to a human
arm. Each of the links of the arm are connected together by joints. Unlike human arm joints,
which are all rotational joints, robotic arm joints may have the ability to change the length of the
link (prismatic joints). The end of the arm of a robot is usually called the end effector. It can be
seen as the “hand” of the robot. End effectors are pretty much the work part of arms and can be
designed for many different tasks. Robotic arms can be made to be moved manually and
autonomously as well. It all depends on what the robotic arm is needed for.
The Denavit-Hartenberg (D-H) approach is one of the most commonly used ways for
creating a reference frame for robotic arms. This method was produced by Jaques Denavit and
Richard Hartenberg. With this method, the transformation from one joint to the next is created
by using the product of four simple transformations which are multiplied together from left to
right in this order:
1.) A rotation (Θ) about the frame’s z-axis
2.) A translation (d) in the z direction
3.) A translation (a) in the x direction
4.) A rotation (α) about the frame’s x-axis
Each of the transformations uses the frame from the joint before as its starting place. These
frames are made so that the z-axis is in the direction of the joint axis. If two consecutive z-axes
intersect, the x-axis of the latter frame is the cross product of the two z-axes. If they do not
intersect, the x-axis can be made to point in any direction as long as it is perpendicular to the z-
axis of the frame. This is convention is used to create a minimal representation of the joints.
Because the each joint frame is based on the frame of the joint before, the kinematics of each of
the joints are much easier to solve for. This also makes it easy to find the position of the final
joint as well.
Approach
For this Project, I programmed the robotic arm simulator using Matlab. I chose Matlab
because it deals with matrix math nicely, and it has its own general user interface (gui) system
built in. The program works by first asking the user if a .mat file is saved with the parameters
need to create the robot. If the user says yes, the program gets the name of the .mat file and
then creates the robot based on the parameters in that file. If the user says no, then it goes
through the system of getting the D-H parameters from the user. Once the program has the
needed parameters, the program creates the robot simulator with all of the user interface pieces
that are needed.
Getting D-H parameters
In order to get the D-H parameters from the user, I decided to use the command window
that is in Matlab. I chose to use the command window because it seemed like the simplest way
to have the program interact with the user. I also thought it would be a little quicker to have the
user type in all of the parameters for one joint all at one time as opposed to typing one
parameter in at a time into a chart. When the program begins, it will ask the user for the number
of joints that the robot arm will have. The program allows the user to put in a joint number that
is less than 6. After the amount of joints is chosen, the program will ask for the D-H parameters
for each of the joints. The parameters have to be put in joint by joint. After the parameters are
put in for a joint, the program asks whether the joint is revolute or prismatic. Once all the joint
information is given, the program then asks about the height of the initial joint. I chose to ask for
the initial height, because it gave the user another degree of freedom when making the robot for
the simulator. Here is an example of how using the initial height can change the look of the
simulator’s representation of your robot.
Figure 1: Picture of a SCARA robot
After the parameters for the joints and the initial height are put in, the program will ask
the user program will ask the user a series of questions to get the orientation of the initial joint.
The program assumes that z-axis of the initial joint frame is either parallel or perpendicular to
the ground. It also assumes that if the z-axis is perpendicular to the ground, the direction of the
z-axis is pointing up with respect to the world. I made this assumption because all of the D-H
Figure 2: The simulator's representation of the SCARA using an initial height of 0 and putting the height in the D-H chart
Figure 3: The simulator's representation of the SCARA using the initial height of 250mm and taking the initial height out of the D-H chart
representations of robots that I have seen so far do not have the initial z-axis pointing into the
ground. The questions will ask about the z and the x axis of the initial joint and how they are
orientated. Once it gets the information about the orientation, it will ask the user to input a name
that will be the name of the .mat file that has all of the information to simulate the user’s robot. I
chose to save out the .mat file because it allows the user to create a simulation for a robot that
has been made before without having to reenter the parameters. This makes using the
simulator faster in the long run.
Figure 4: Example of how the entering the parameters works
Creating the Work Area, Links, and Joints
When creating the work area for the robot, I took the height of the initial joint and the
length of the links into consideration. The work area is centered on the position of the initial
joint. The floor is set in the negative direction and is set at the negative of the initial height. The
ceiling and the sides of the work area is set to 30mm longer than the sum of the all the largest
length of the links. It takes into account whether the joint is prismatic or revolute. This is done
because if a joint is prismatic, the length of that link could change.
The joints are represented by an xyz-frame. For each of the frames, the x-axis is
represented by a red line, the y-axis is represented by a green line, and the z-axis is
represented by a blue line. I chose this representation because it lets the user see how each of
the joints is moving a lot easier than if there was no lines drawn for the axis. The placement
and the orientation of each of the joint frames will be determined by the initial joint position and
the D-H parameters given to the program. The length and the thickness of the axis lines are
fixed sizes, but if the 2 of the joints have the same origin, the program will draw the lines for the
second joint a little thinner and a little longer. This is to be able to tell the difference between 2
joints at the same origin.
Figure 5: Example of how the length and width of the lines for the axes are different if the origins of 2 joints are the same.
The links for the robot arm is represented by black lines. The line connects the origin of
one joint frame to the origin of next joint frame. A line is also drawn from the floor to the origin
of the initial joint frame if the initial joint is not on the floor of the work area. Because the joints
can be prismatic, the length of the links can change. No matter the length of the link, the line
will always connect the 2 joints.
User Interface
Once the program gets all of the parameters that it need, the user interface with the
robotic arm simulator will pop up. On the user interface, there will be sliders and edit boxes for
each of the joints that the robot has. If the joint is revolute, the slider is set to work from -180 to
180 degrees, and the edit box will only accept entries between -180 and 180. If the joint is
prismatic, the slider is set to work from -400 to 400 mm. The edit box for prismatic joints only
allows for entries between the slider settings as well. When the slider changes, the number in
the edit box will change to correspond with what the slider is showing. The same thing happens
the other way as well. If the number is changed in the edit box, the slider will change to
correspond with the change in the edit box. Each edit box, slider set will be labeled based on
which joint it controls and whether the joint is revolute or prismatic. If the joint is prismatic, the
joint controls will have the label “d” and the number of which joint it controls. If it is revolute, it
will have the label “Th” and the number of the joint.
The user interface also has a “go home” button. The purpose of this button is to have
the robot go straight to its original position. The original position is based on the D-H
parameters that were given to the program by the user or a .mat file. I decided to add this
button so that the user could easily get the robot back to its original position without have to set
each of the joints one by one. This will save the user some time.
The final thing that is shown on the user interface is the XYZ and the OAT positioning of
the end effector. The positions are updated after one of the joint settings has changed. The
positions that are displayed are the coordinates and orientation with respect to the world
coordinates. I believe that having the position with respect to the world, instead of the initial
joint frame, would cause less confusion with the user. Since the world’s origin and the initial
Figure 6: Example of the slider and edit boxes when there is only one joint
Figure 7: Example of the slider and the edit boxes when there are 6 joints
joint frame’s origin are always in the same position, the XYZ and OAT are always with respect
to the initial joint’s positioning, not its orientation.
Figure 8: Picture of what the XYZ and OAT outputs look like
Results
To test how well my robotic arm simulator works, I wanted to look at 2 aspects of it. The
first is how the simulator’s robot looks in comparison to actual robots that have been built or
robots that have been created in a drawing. This is to see if the way I chose to represent the
robot allows for the user to imagine it as an actual robotic arm. To test this, I input the D-H
parameters of previously made robots, and compared the pictures of the simulated robot to the
pictures of the actual robot. The second part that I tested was the position of the end effector
and the give coordinates for the end effector. This is to test and see if my simulator is actually
moving in the right directions so that the end effector ends up in the correct coordinates. To do
this test this part, I gave my program the D-H parameters for the Puma560, and compared the
position that my simulator is outputting to the position that is given by the Robotics Toolbox for
Matlab for the Puma560.
Testing the Look of the Simulator
Figure 11: Another example of a robot Arm from Dr. Desouza's Lecture Notes. This example has both prismatic and rotational joints
Figure 12: My programs representation of the robot arm on the left
Figure 13: This is a picture of an actual Puma 260 robotic arm
Figure 14: This is my program's representation of a Puma 260 robotic arm
Testing the Position of the End Effector
Table 1: The results for with all of the thetas being 0 degrees
all theta are 0 degreesx y z
Toolbox Puma 560 simulator .452 m -0.15 m .432 mMy program's Puma 560 simulator 452 mm -150 mm 431 mm
Table 2: The results with all of the thetas being 30 degrees
all thetas are 30 degreesx y z
Toolbox Puma 560 simulator .084 m -0.125 m .449 mMy program's Puma 560 simulator 83.8 mm -124 mm 449 mm
Figure 15: This is my program's simulation of the Puma 560 with all joint angles equal to 0 degrees
Figure 16: The Robotic Toolbox's simulation of the Puma 560 with all joint angles equal to 0 degrees
Table 3: The results with all of the thetas being 90 degrees
all thetas are 90 degreesx y z
Toolbox Puma 560 simulator 0.15 m -.020 m 0 mMy program's Puma 560 simulator 150mm -20 mm 0 mm
Figure 17: This is my program's simulation of the Puma 560 with all joint angles equal to 30 degrees
Figure 18: The Robotic Toolbox's simulation of the Puma 560 with all joint angles equal to 30 degrees
Figure 20: The Robotic Toolbox's simulation of the Puma 560 with all joint angles equal to 90 degrees
Figure 19: This is my program's simulation of the Puma 560 with all joint angles equal to 90 degrees
Table 4: The results with thetas 0, 30, 45, 60, 90, 0
0, 30, 45, 60, 90, 0x y z
Toolbox Puma 560 simulator -.038 m -.150 m .347 mMy program's Puma 560 simulator -37 mm -150 mm 347 mm
Table 5: The results with thetas 0, 90, 0, 45, 0, 60
0, 90, 0, 45, 0, 60x y z
Toolbox Puma 560 simulator -.432 m -.150 m .452 mMy program's Puma 560 simulator -431 mm -150 mm 452 mm
Figure 21: This is my program's simulation of the Puma 560 with joint angles equal to 0, 30, 45, 60, 90, 0 degrees
Figure 22: This is the Robotic Toolbox's simulation of the Puma 560 with joint angles equal to 0, 30, 45, 60, 90, 0 degrees
Note: The reason that the last two set of pictures do not match up as much as the first 3 is
because the axis values for the Robotic Toolbox simulator get inverted.
Conclusion Future Planning
Overall, the project went well. In comparing my simulator’s creation of a robot arm to a
picture of an actual robot, I believe that were pretty similar. It does not look exactly like the
actual robot and in some cases, my connectors do not look like connectors for the actual robot,
but it always has the same joint movements as the actual robots. Also, not having a robot look
for my simulator helps keep the imagination of how the robot should look up to the user. In
addition, I believe showing the axes for the joint helps the user to see joint changes in all
conditions. Without the axes, there may be some positions that the robot could get into and
changes could become hard to see. With that I think that the project was a success.
Even though, most things went well, there are things that can be fixed and improved
upon in the future to make the simulator work better. The first would be in how the parameter
entry system works. I would like to add more error checking to the entry system that already
Figure 24: This is my program's simulation of the Puma 560 with joint angles equal to 0, 90, 0, 45, 0, 60 degrees
Figure 3: This is the Robotic Toolbox's simulation of the Puma 560 with joint angles equal to 0, 90, 0, 45, 0, 60 degrees
exists. For instance, when the system asks’ a yes or no question, the program assumes no if it
is not yes. In the future, I would add more checking so that if the answer is not yes or no, the
system will ask again. Also, when the system asks for the name of a .mat file, the system may
stop running if the filename was put in incorrectly. There should be more error checking in this
part so that doesn’t happen.
Adding more than one way to let the user enter the parameters would be the next part
that I would like to add to the program in the future. The program could somehow let the users
decide on how they want to enter the information that is needed. I could add a user interface so
that the user can enter the information like in a chart if that was the way the user wanted to
enter the information. Another add-on that would help the user would be to have the system to
allow for changes in an existing .mat file so the user can make a few changes without having to
input all of the parameters again. Because I would like to give the user full control over all of the
parameters, I would like to have the user be able to decide on the minimums and maximums for
the joint movements. This would allow the user to be capable of seeing the robot simulated with
the same restrictions that the actual robot will have.
The final part that I would like to add to the program is to have the length and width of
the lines be created more dynamically. As the program stands now, these parameters of the
lines are set parameters. This means that if someone was trying to simulate a larger robot arm,
the axes for the joints will be a lot smaller in comparison, making harder for the user to see. If
the axes were made to change in length and width dynamically, the lengths would be longer and
wider as the lengths of the links became longer. This will help the user to see everything better
visually.