• Aprameya

RobotStudio Handbook

Updated: Jan 29



RobotStudio is the software package developed by ABB industries to program, simulate, and communicate its industrial robotic arm product line. This software lets us program the robotic arm in off-line mode, model work cell, and the equipment for simulation the workflow, and finally communicate and control a robot through a network.

RobotStudio also has a built-in integrated development environment (IDE) to edit codes written in the RAPID language. For more information please refer to the RobotStudio web page.

Basics

Installation and Licensing:

Download the installation files from the ABB website directly and use the licensing server at the dFab to activate it on your personal machine.

Note: To activate and use RobotStudio, your machine should be connected to CMU's network. For that, you should be on the campus or use CMU VPN service.


RobotWare legacy versions:

In order to properly use a robot, you should have the correct version of RobotWare installed on RobotStudion. As per ABB's bulletin: "RobotWare is a family of controller software designed to make you more productive and lower your cost of owning and operating a robot."

You need to have the same version of RobotWare on both your computer and the robot you are going to work with. RobotStudio is being shipped with the latest version of RobotWare. If you need to use older versions, you need to manually download it through Add-Ins tab in the ribbon.

Select the RobotWare icon in the RobotApps panel, then chose the version that you need from the RobotWare panel on the right. Follow the installation process after downloading the package.


Figure 1- Installing RobotWare legacy versions

Note: If you are using RobotStudio 2019, you cannot easily access RobotWare 5 from this guide, but you can find it on ABB's website).

Interface:

Figure 2- RobotStudio User Interface


Ribbon: In the ribbon, you can select different tabs of tools for different tasks, like modeling, simulation, developing RAPID code and manage your add-ins.


Sidebar: In this bar, you can find all the robots, target points, tasks, and modules.


Main Viewport: This is your main desktop. You can view your robot simulation, edit your code, edit IO’s, etc. This panel is configurable and you can expand its sub-panels into your second screen.


Output Panel: This panel is useful for monitoring messages and feedbacks from the system. The output is the default active panel in this section.


Status bar: Not to be confused with the sidebar, this narrow bar at the bottom of the screen is a permanent display for monitoring your model status.


Navigation: Navigation in 3D space is slightly different from other 3D software packages that you might be familiar with:

  • Pan: Left mouse drag + ctrl

  • Zoom: Mouse wheel

  • Rotate: Left mouse drag + ctrl + shift

Offline Programming RobotStudio:


Offline programming will let you use a graphic interface and 3D modeling environment to model your work cell, program your robot, and simulate it. In this section, we will go through the basics of this procedure. For a basic 3d-based offline programming, we need to at least define these items:

  1. Robot(s)

  2. Tool(s)

  3. Target points

  4. Path

Once we have all these items set, we can simulate the robot behavior while moving its TCP along the path.


Setup a project:

Figure 3- New Project Menu


To make an empty project, you can use “Solution with Station and Robot Controller” option. Make sure that you are selecting the appropriate RobotWare version and robot model. Currently, we are using RobotWare 6.02 in the lab. RobotWare is usually not backward compatible, using the wrong RobotWare version will render your project incompatible with the dFab setup.


Robot Setup:

You should select your robot model in this step from these two options:

  • IRB 6640 150kg 2.55m LeanID

  • IRB 4400 60kg 1.96m

Once you select your robot and RobotWare, RobotStudio will set up your file. It may take a while until you get the robot model and a green light for controller status on the status bar.


Figure 4- New Project with IRB-6640-150kg Robot


Tool setup:


Setting up tool geometry: You need to model your tool in Rhino or other 3D modeling software first. Then export the model in .stl format. Don’t forget to set your modeling unit into mm before exporting.

The z axis of your tool should face upward in Rhino (+Z direction). An easy way to figure out the tool’s z axis is to think of the tool as it is installed on the robot, the axis that starts from the robot wrist and directly points outward is your tool’s z axis. (Please refer to Figure 5 where the blue line refers to tool’s z axis) The tool center point must be located at the center of coordination system. You should measure the distance from TCP to the at which the tool attaches to the robot. We will use this measurement to offset the TCP z value in RobotStudio. In RobotStudio, select Home from the ribbon, then select Import Geometry > Browse for Geometry. Navigate to the folder you saved the tool’s model and import it to your file. You can also drag/drop the .stl file directly to the viewport.

Figure 5- Finding Tool’s z axis


Setting up a tool in RobotStudio: After importing the tool’s model, go to the Modeling tab and select create tool. It will open a menu where you can set desired properties for your tool. (Figure 6)


Figure 6- Create Tool Menu


  • Assign a meaningful name for your tool.

  • Select the existing geometry that you just imported.

  • Set mass and center of gravity carefully, especially for heavy tools or those which may require rapid motions. And hit Next.

  • In this window, you need to enter the offset values to change the location of the tool’s TCP. If your tool only has z offset value, import the value you measured in Rhino. Then hit the long arrow button.

  • Hit Done

A new tool will be added to the Layout panel. Right-click on it and select attach to, then choose your robot. It will automatically attach to the robot wrist and from now, they will move together.


Target Setup:


Targets are poses in space that the robot will move the tool center point to them. Every target point is defined by two major property:

1- Position: the distance from the center of the coordination system along the coordination axis (x,y,z).


2- Orientation: It defines the direction of the target point. In RobotStudio, you can define orientation by the amount of rotation around every coordination axis (also known as yaw, pitch, roll angles). However, in RAPID, orientation will be defined in quaternion format [q1,q2,q3,q4]. The combination of position and orientation defines the Pose of the target. Every target also has other properties that will be discussed in the RAPID section. There are three main methods to make a target:


1- Teach the point Jog the robot to a point in space, and click on Ribbon> Home > Teach Target. The current robot’s TCP pose will be saved as a target and will be listed in the sidebar under Path and Targets>Your Robot> YourModule> YourWorkObject.


2- Declaring a target by values To declare a target point, go to Home tab and select Target> Create Target. If you have not defined a workObject yet, it will remind you to define one. In the Create Target panel, you can insert both Position values (in the x, y, z format) and Orientation (in the yaw, pitch, roll format) you can add several points and hit Add button after each one. Once you are done with all the points, hit Create to generate all the points. The targets will be added to your active workObject automatically. However, the yellow exclamation mark next to the target logo indicates that the target needs to be modified before the robot can reach it. Right-click on the target and select Jump to Target, it will open the Robot Configuration menu, where you can define the configuration of the robot to reach that specific target. (Figure 7).




Figure 7- Target Edit Menus



A robot can reach the same point in different configurations which may result in different challenges. Some of the configurations may interfere with your work cell setup or force the robot to perform unnecessary maneuvers. In the example in Figure 8, both configurations seem to be similar, while one of them enforces a 180-degree rotation on joint 4, which may result in unwanted consequences.


Figure 8- Selecting Robot Configuration


You can apply the same procedure to the rest of the target points manually. However, this is not practical when you have hundreds of target points. For this, we need to go to define a path and automate the configuration.

3- Autopath: This command lets you generate targets along a curve or edge of a geometry. You need to make a geometry from Ribbon> Modeling. Then go to Ribbon> Home> Path> Autopath and select the edge of the geometry that you previously made. You may need to check these targets for reachability and configuration issues. This method will line up the targets in a path automatically.


Figure 9- Generate targets using Autopath


Path:

So far, we defined targets. But we want the robot to move between those targets. To do so, we need to make a path. To do so, simply select the targets that you want to go through in the sidebar and right-click on them. From the menu, select Add to new path, or if you already have a path select, Add to path>your path. This will generate a new path with the selected targets and a yellow line highlights your path on the viewport. This line connects targets in the order and indicates the direction of movement between them.


Figure 10- Path before configuration


Path Adjustment: When making a new path, we may have not set the robot configuration on each point. In such cases, there will be a yellow mark next to each target of the path. To solve this problem, right-click on the path and select configuration>auto configuration. RobotStudio will ask you to manually select a configuration if it cannot decide between possible ones, and then simulate the whole path once.



Figure 11- Path after configuration


here is another tool that will help you to adjust your path and inspect it before a full simulation; By right-clicking on the pathname, you can select Move along path to simulate robot motions along that specific path.



RAPID

While we use the 3D interface to teach the robot, we need to compile a RAPID code to use it to control the robot. To do so, we need to use Ribbon> Home > Synchronize. RobotStudio will automatically compile a RAPID code and includes all the definitions and settings that we have already created. If you go to Ribbon> RAPID, you can see the results in the side bar you can see the structure that code.



Figure 12- The structure of the RAPID code on the left side-bar before/after synchronization


We will not change the System Module values and will only work with the program modules. You may not have a main module in your model, hence you will need to create one. Simply add it between your target definition and first path routine. (Please refer to Figure 13) If you simulate this code, nothing will happen, since the main procedure is empty and no other module has been called there.



Figure 13- RAPID code after synchronization


Debugging:


For the sake of doing a simulation, we will add code to move the robot along the Path_10 and Path_20. For this, we need to call Path_20 and Path_10 procedures (routines). This can be done by adding these two lines inside the main procedure:


Path_10;

Path_20;


Now, your RAPID code should look like Figure 14. After this, you need to apply these edits by hitting Ribbon> RAPID> Apply .

You are all set to run this RAPID code. But first, you need to put Program Pointer at the beginning of the main procedure. To do so, on the sidebar, right-click on YourRobot> RAPID> YourTask> YourModule> main and hit set program pointer to routine. Doing so, a yellow arrow shows up in front of your code next to the first line of the main procedure.

Now, if you hit Ribbon> RAPID> Play every line of code in the main procedure will run one after each other and you can see the results in the main viewport.


Figure 14- Setting Program Pointer at the main module


Simulation: While running a RAPID task is a good way of debugging your RAPID code, to perform a real simulation, you need to use the simulation tools provided in RobotStudio. To do so, go to Ribbon> Simulation> Play. You can watch the simulation to make sure no unexpected event is happening, or record the simulation for further review using Ribbon> Simulation> Play> Record to viewer.


Carnegie Mellon University

School of Architecture

by Ardavan Bidgoli


47 views
  • Academia
  • Google Scholar
  • Research Gate
  • Github
  • YouTube
  • LinkedIn
  • Twitter

© 2015-2020 by Ardavan Bidgoli