1

ME 5286 Robotics Labs

Lab 1: Hello Cobot World

Duration: 2 Weeks (1/28/2019 – 2/08/2019)

Note:

At least two people must be present in the lab when operating the UR5 robot. Upload a

selfie of you, your partner, and the robot to the Canvas submission link before starting the

lab. Read all warnings and cautions in the manual.

Once you are done with all your tasks for the day,

1) Save all your programs to permanent storage (i.e. flash drive or H drive) and

2) Remove all of your programs from the Robot’s computer.

Failure to remove your programs from the robot’s computer will result in a loss of points.

Objective:

Familiarize yourself with the UR5 robot and PolyScope, RoboDK, and the RoboDK Python API

programming environments. RoboDK Python API is an extension of RoboDK that allows the

user to program the robot through a Python script, whereas with regular RoboDK, it is done

through a graphical user interface. During this lab you will move the robot through specified

waypoints in joint and Cartesian space using all three programming methods and tracing a virtual

cube.

Prelab:

- Read the UR5 lab manual and understand:

o There is a lot of important information in the manual. In particular, read the

section on Risk assessments pp. I-1 – I-11 of the UR5 manual, and Collaborative

robot safety standards: ISO/TS 15066, ISO 10218-2 (details on course website).

o There are small differences between the 2 robots; that is why we make available 2

different versions of the manual. We also provide the manual for the URScript

Programming Language.

- Install RoboDK

o Understand the End User License Agreement (EULA) when installing RoboDK

o See the Announcements page on Canvas to set up the license for class use

- For each of the labs, be sure to stick with the same robot. Do not switch robots in the

middle of the lab. Results may not be consistent.

2

Lab Procedure:

The first part of the lab will consist of moving the robot through 3 different poses in both

Cartesian and joint space using PolyScope, RoboDK, and RoboDK Python API.

The poses that you will be moving through are as follows:

X (mm) Y (mm) Z (mm) RX (rad) RY (rad) RZ (rad)

Pose 1 -575 -350 300 2.10 1.11 0.63

Pose 2 -240 -445 650 1.57 -1.57 -1.57

Pose 3 400 -400 200 2.79 -0.16 0

- The robot’s pose (position and orientation) of the tool or end effector is described in

Section 12.2 starting on page II-36 of the manual.

- PolyScope and RoboDK are visual programming environments.

- RoboDK Python API is a powerful tool that allows you to program in Python and

visualize robot movements within RoboDK. A post processor is used that converts the

Python code to URScript, a language the UR5 understands.

Task 1:

Move the robot through a set of poses in both Cartesian and joint space using PolyScope (Tablet

connected to the UR5).

Task Steps

1) Ensure the TCP offset parameter of the robot is set to the correct value of 0.0. How to

change this parameter is outlined in the appendix.

2) Press “Program Robot” on the PolyScope Robot User Interface page (Figure 1).

3) Press “Empty Program” (See Figure 2)

4) Navigate to the “Structure” tab and press “Move”.

5) Click on “MoveJ → Waypoint” in the robot program and then press “Set this

waypoint”.

6) Set the Tool Center Point (TCP) to Pose 1 and press okay. [See pg. II-45 of the robot

manual for definition of TCP]. You may need to free drive the robot to get it close to

the desired pose. Important: Change the “Feature” drop down menu to “Base” from

“View”. This will ensure that you are working in the robot base frame.

7) Repeat steps 4 and 5 for Pose 2 and Pose 3.

8) Click on the “Graphics” tab (Figure 4: PolyScope move robot interface) and click the

“Simulation” bubble. Then press “Play” and verify that the robot is doing what you

expect it to do.

9) In the “Graphics” tab, press “Real Robot” and then press play and watch the robot

perform its task.

3

10) Press “MoveJ” in the Robot Program and change the “MoveJ” to “MoveL” and repeat

steps 7 and 8.

Figure 1: PolyScope home screen

Figure 2: New program screen

4

Figure 3: Robot programming initial page

Figure 4: PolyScope move robot interface. The UR5 robot joints are shown in Figure 13.1 on pg. II-39 of the robot’s manual.

5

Figure 5: Defining a robot pose

Task 2:

Move the robot through a set of poses in both the Cartesian and joint space using RoboDK.

Note: For this task and the following task, you will encounter times when the robot runs into

itself, where the elbow of the robot runs into the table, and where you run through a singularity

and the robot stops due to singularities. This is normal and part of the learning process with

robotic arms. If you encounter these problems, stop the program, free drive the robot into a new

configuration, and try again (You can free drive the robot by pressing the button on the back of

the teach pendant). Through this process you will get better at understanding the robot’s

limitations and predicting which configurations will give you successful solutions.

Task Steps

1) Open RoboDK on the lab desktop

2) Download and open "ur5_and_table_and_gripper.rdk" from the course website and

save the workspace as “ME5286_Lab1_Task1_[last name]_[first name].rdk.” Note

that this file can still be used even though the gripper will not actually be used for this

lab.

3) Right click on the UR5 and select “options”. Make sure that the tool frame entries are

all 0.0.

6

4) Select the target button

5) Press “F3” or right click and select “options” and assign Pose 1 for Target 1 as shown

in Figure 6.

6) Repeat steps 3 and 4 for Target 2 and Target 3.

7) With the three targets defined, the next step is to create a program to move between

the three targets. Press the “program” button

8) Add a joint space movement by pressing right click and set the target link to

Target 1.

9) Repeat step 7 for Target 2 and Target 3.

10) Right click on “Prog 1” in the command tree and check “Run”. Verify that your path

matches that of the robot path below. In Figure 7, the target frame’s (i.e. the tool

coordinate frame) x-axis is shown as red, the y-axis as green, and the z-axis as blue.

11) If the path of the robot is what is expected, right click on “Prog 1” and press “Run on

Robot”. You will first need to make sure the robot is connected to the computer by

following the directions in the Appendix of this document.

12) Next we will look at moving the robot through Cartesian space instead of through

joint space. Right click on the “Move J” items in the command tree and select

“MoveL”. Repeat steps 9 and 10.

Figure 6: Assigning the robot pose to the target

7

Figure 7: Sample of RoboDK program moving through the three poses in joint space and Cartesian space

Task 3:

Move the robot through a set of poses in both Cartesian and joint space using the Python API

within RoboDK. More information on this can be found here https://robodk.com/offline-

programming.

Task Steps

1) Open RoboDK on the lab desktop

2) Open the "ur5_and_table_and_gripper.rdk" file from task 2.

3) Select Program➔ Add Python program to create a new Python program.

4) Right click on the new program (most likely called Prog1) and click Edit Python Script.

5) Copy and paste the Python script below (Figure 8) into the window that pops up.

6) Save this program as Task_3.py

7) Right click on the UR5 robot and select “Connect to robot” and follow the steps outlined

in the appendix to connect to the robot.

8) To simulate the robot’s movements in RoboDK and check that the robot will move where

expected, right click the script “Task_3.py” and select “Run Python script”

9) Once you are satisfied with the robot's movements, right click on “Task_3.py” and select

“Run on robot”. This will run on the actual UR5 as the Python program is executed.

a. If “run on robot” doesn’t seem to work, try clicking “start on robot” instead.

8

Figure 8: Python program that moves the robot TCP in a square. (see course webpage for script download)

9

Task 4:

Create a program that has the end effector trace the edges of a virtual rectangular “prism”. You

will be tracing two rectangular prisms for this task. The first prism should aim to maximize the

side lengths in the y-direction while the second prism should maximize length in the z-direction.

While tracing the prism edges, the orientation of the gripper should remain the same and only the

(x,y,z) portion of the pose should change. Using your software of choice (i.e. RoboDK,

Polyscope) create a program which defines eight vertices and traces a rectangular prism between

those vertices. You should develop most of this program before you come to your lab session to

ensure that you are able to finish on time.

Note: Your prism can be skinny but must have some width. This isn’t an optimization

problem; you don’t need to spend time creating a formula to maximize the side lengths. The

goal of this task is for you to become familiar with the robot workspace, just try to make the side

lengths as large as you can (for the direction you are focused on) without spending too much

time. The base coordinate frame is shown in Figure 9.

Figure 9: UR5 with the base coordinate frame shown.

10

Task 5:

In this task, the robot is equipped with an aluminum semi-cylinder as its end effector as seen on

the left side of Figure 10. Another semi-cylinder is attached via four load cells to two t-slot

extrusions mounted to the table as seen on the right side of Figure 10.

Note: You are not conducting any experiment for this task. As mentioned in class, the

experiment has already been completed by the TAs and the data will be provided for you to

analyze.

Figure 10: UR5 with collision end effector (left) and collision force plate (right)..

Although you are not conducting the experiment, the steps are outlined below for your reference

so that you can understand how the experiment was performed. This will help you with your

analysis.

Task Steps

1. Prepare the Python code in order to configure the robot as shown in Figure 10. The two

aluminum semi-cylinders should be perpendicular to each other. The robot should be

positioned around [X= 300, Y= -420, Z=200].

2. Have the robot move along a straight line (using MoveL) to a point beyond the collision

fixture. This allows the robot to fully collide with the fixture during which the force will

be recorded.

3. BEFORE running your code on the robot, run your code offline on RoboDK. This allows

you to ensure that the robot is doing what you expected. This is good practice and should

be done for all the laboratory modules.

11

4. Run the following experiment three times at each speed setting in a range from 0 to 1.2

m/s. To do this, move the end effector so that it collides with the collision fixture at speed

increments of 5% of the max speed (1.2 m/s) between 0 and 0.6 m/s and in 10%

increments between 0.6 and 1.2 m/s. Be sure to record the data using the PuTTY

software.

(see Miscellaneous Instructions and Troubleshooting Guide on the course web site’s Lab

Assignments page for using PuTTY).

For reference, the collision speeds that were run are; 0.06, 0.12, 0.18, 0.24, 0.30, 0.36, 0.42, 0.48,

0.54, 0.60, 0.72, 0.84, 0.96, 1.08, 1.29 m/s.

You will be given the results of this experiment which can be downloaded from the course

webpage. You will be analyzing these results as described in the deliverables section.

Deliverables:

- A single zip file named [last_name]_[first name]_helloworld.zip containing all robot files

(RoboDK, Python, Universal Robot Projects) uploaded to Canvas.

- A hard copy turned in during class and a PDF file uploaded to Canvas, in memo format,

which includes:

Task 1-3:

1) Describe the difference between joint and Cartesian space and how that affected the

motion of the robot.

2) Describe the limitations of the robot’s workspace based upon the mounting location

of the robot on the table.

3) Show the usable workspace of the robot. Use a program (Matlab, Excel, etc) to plot

the workspaces. This can either be a 3D view or multiple 2D views.

4) What are the two safety planes? And how did you determine where they were?

5) Is the robot elbow up or elbow down for these tasks? How do you know and how did

you ensure that the robot chose this elbow configuration?

6) Define what “collaborative” means when talking about “collaborative robotics”?

7) Compare and contrast the three programming methods. Which do you find easiest to

use at the moment? Which method seems to have the most capabilities or lack of

capabilities? Which method do you foresee yourself using for the rest of the class?

Task 4:

1) Create a table showing the vertices you used in the cube and describe how you picked

these vertices.

2) What does that tell you about the robot’s workspace?

3) Include a screenshot or figure of the robot trajectory tracing the two cubes.

Task 5:

12

1) Create a plot showing the force exerted by the robot vs. speed of the robot. (To do

this, average the three forces measured at each speed and plot this average force vs

speed)

2) What does the above plot say about the UR5 strategy for preventing excessive forces

when colliding?

3) What was the maximum force recorded and at which speed?

All deliverables due on Friday, February 15th at the START OF CLASS.

13

Appendix:

Changing the TCP (tool center point) Offset on the UR5

The TCP offset is an important parameter on the robot when dealing with tools mounted on the

end-effector. A TCP offset of 0 is a point on the end-effector without any tool mounted. For a

more in-depth explanation of the TCP, see the robot manual section 13.6, page II-45.

To change this value:

1) Go to Robot Settings

2) Click TCP Offset

3) Change to desired value

4) Save

Connecting to the UR5 with RoboDK

Important: Make sure you are connecting to the IP address of the robot you are using (step 3).

There are signs on the wall near the robots with the appropriate IP addresses. Connecting to the

wrong robot is dangerous to the other group.

1) Right click on the UR5 robot.

2) Select “Connect to robot…”.

3) Enter the IP address of the robot you are using (below) and the Robot port of 30000

(Figure 11).

a. Robot #1 IP: 172.19.29.21

b. Robot #2 IP: 172.19.29.22

4) Select “Connect”. You should see the message “Ready” in green if the connection

succeeded. If it doesn’t connect, try double clicking Disconnect and then click

Connect.

5) A program can be automatically started by selecting “Start on robot”. A program can

also be executed sequentially with RoboDK by selecting “Run on robot”.

14

Figure 11: Connecting RoboDK to the robot controller

Transferring a URScript file to the Robot with FileZilla (see Figures 12-14):

Steps 6, 7, 8 and 9 are identified in Figure 13 (FileZilla Site Manager settings).

1) Within PolyScope go to “Installation” → “EtherNet/IP” and press “Enable” (Figure

12)

2) Open up a session of RoboDK with the UR5 robot.

3) Right click the UR5 robot and select “Connect to robot…” .

4) Select “Explore” which will open FileZilla, a software application for transferring

files using FTP.

5) Within FileZilla select “File” → “Site Manager…”.

6) Within the popup menu, select “Universal Robot sample” (Figure 13).

7) Select “Duplicate,” a copy of the Universal Robot setting will then be created and

name the copy ur5-1.

8) Enter the IP of the robot for the Host ( Robot #1: 172.19.29.21 or Robot #2:

172:19:29.22) and use Port 22.

9) Select “Connect”.

10) Transfer the SCRIPT file to the robot by first locating the file to transfer under “Local

site:”. (Left side of Figure 14)

11) Next change the “Remote site:” to “/programs” which is the default file location for

the robot controller.

12) Right click on the file you want to transfer and select “Upload”. Choose to overwrite

the file on the robot controller.

13) To run the script add a “Script Code” block and change the drop down to “File,” then

press “Edit” → “Open” → select transferred file

14) To update a script file on the robot controller, repeat the transfer with FileZilla and

press “Edit” under “Script Code”. You should then see the updated script code.

15

Figure 12: Enabling the Ethernet for the robot controller with PolyScope

Figure 13: FileZilla Site Manager settings to connect to UR5.

Step

Step

Step

Step

16

Figure 14: Transferring a file using FileZilla

Local

site