Industrial robots are highly repeatable but not accurate, therefore the accuracy of an industrial robot can be improved through calibration. The nominal accuracy of a robot depends on the robot brand and model, as well as how much it can be improved. After robot calibration, the robot accuracy can be improved by a factor varying from 2 to 10 or even mor
A measurement system is required to calibrate a robot. RoboDK can be used to calibrate the robots as well as to generate accurate robot programs (this includes filtering the programs and using RoboDK’s offline programming engine). RoboDK can also be used to test the accuracy of the robot before and after calibration through ballbar testing or robot milling.
Robot calibration can remarkably improve the accuracy of robots programmed offline, also known as Off-Line Programming (OLP). A calibrated robot has a higher absolute as well as relative positioning accuracy than an uncalibrated one.
It is recommended to watch the following
video to see a complete calibration of an industrial robot using RoboDK:
The following items are required to install RoboDK and properly perform robot calibration:
1. One or more industrial robot arms
2. A measurement system: any laser tracker such as Leica, API or Faro and or optical CMM such as the C-Track stereocamera from Creaform should work
3. RoboDK software must be installed and an appropriate license for robot calibration testing is required. For network licenses, an internet connection is required to check the license. To install or update RoboDK for robot calibration:
a. Download RoboDK
from the download section
Set up the driver for the measurement system (not required for
Creaform Optical CMM).
Unzip and copy the appropriate folder:
API Laser tracker: https://robodk.com/downloads/private/API.zip (OTII and Radian trackers)
Faro Laser Tracker: https://robodk.com/downloads/private/Faro.zip (all Faro Trackers)
Leica Laser Tracker: https://robodk.com/downloads/private/Leica.zip (all Leica Trackers)
to the folder: C:/RoboDK/api/
It is recommended to create a virtual environment of the robot setup in RoboDK (offline setup) before starting to take measurements. This section explains how to prepare the RoboDK station offline. This can be done before having the robot and the tracker, only using a computer with RoboDK installed.
RoboDK calibration setup examples can be
downloaded from the following folder:
Skip this section if you already have an offline cell. The reference frames and tool frames can be estimated approximately. A sample station is shown in the following picture.
Note: The getting started section provides more information about creating a new RoboDK station.
A RoboDK station is where the virtual environment station and calibration information is stored. The station is saved as an RDK file. Follow the next steps to create a robot station for robot calibration from scratch (video preview: https://youtu.be/Nkb9uDamFb4):
1. Select the robot:
a. Select File➔Open online library. The online library will show up in RoboDK.
b. Use the filters to find your robot by brand, payload, ...
c. Select Download and the robot should automatically appear in the station.
d. Alternatively, download the robot files (.robot file extension) separately from http://www.robodk.com/library and open them with RoboDK.
2. Model the virtual station
a. Add reference frames by selecting Program➔Add Reference Frame.
i. One “Measurements reference” frame must be added with respect to the robot base frame.
ii. One “Tracker reference” must be added with respect to the “Measurements reference” that we just added.
iii. One additional “Tool reference” can be added with respect to the “Measurements reference” frame to visualize the position of the tool seen by the tracker.
Tip 1: Drag and drop items in the tree to reconstruct the dependency that exists in the real world. For example, the tracker reference must be placed with respect to the “Measurements Reference”.
Tip 2: Approximately move any reference frames or tool frames by holding the ALT key and SHIFT+ALT key respectively. Alternatively, double click the reference frame and input the right coordinates.
Tip 3: Rename any object using the F2 key on the item tree.
b. Add the tool object (STL, IGES and STEP files are supported formats) and drag and drop it to the robot (inside the item tree), this will convert the object into a tool. More information available here.
Optional: Select Program➔Add empty tool to add any TCP’s that we want to visualize in the station (to check for collisions or other). To set an approximate value of the TCP:
i. Double click the new tool.
ii. Set an approximate TCP value. You can copy/paste the 6 values at once using the two buttons at the right.
iii. It is recommended to rename the TCPs used for calibration with the name “CalibTool id”, where id is the calibration target number.
c. Add other 3D CAD files (STL, IGES, STEP, SLD, ...) to model the virtual station using the menu File➔Open… Alternatively, drag and drop files to RoboDK’s main window.
Tip 1: Import the 3D files of the measurement workspace and name it Workspace so that the robot measurements are generated inside the workspace of the tracker. Alternatively, set the workspace invisible if we do not want to constrain the measurements inside the tracker workspace. More information is available in the next section.
Tip 2: It is possible to select CTRL+ALT+Shift+P to block exporting confidential 3D files that have been imported in RoboDK.
3. Add the calibration module in the station:
a. Select the menu Utilities➔Robot Calibration.
b. Select Laser tracker.
Then, the following window will appear.
This window can be closed for now. We can open it anytime by double clicking the Robot calibration station item.
Tip: To only calibrate the home position of the robot (also known as “mastering” or “homing”), select Calib. param. on the calibration settings, then, select “Mastering/Home (16)”. Otherwise, leave it as Complete, which is the calibration type used by default and allows improving accuracy further.
4. Save the station.
a. Select File➔Save station.
b. Provide a folder and a file name.
c. Select save. A new RDK file will be generated (RoboDK station file).
We can recover the station modifications anytime by opening the RDK file (double click the file on Windows).
It is important to double check the following details:
1. The calibration tools are named “CalibTool id” and the id are numbers start at 1 (if there are 3 calibration tools we must have “CalibTool 1”, “CalibTool 2” and “CalibTool 3”.
2. The Measurements reference frame directly depends on the robot base.
Important: The measurements reference frame must have a similar orientation to the robot if we want to recover the home position for axis 1. We must be able to measure this reference frame in a very repeatable way using 3 points. See Annex I for more information.
For now, we can use an estimate of this reference frame.
3. The Tracker reference directly depends on the Measurements reference. The tracker reference must be an approximate position of the laser tracker with respect to the measurements reference.
4. The Robot calibration project is present in the station and all the measurements that we are planning to take are free of collision and visible by the laser tracker (select show for each group of measurements).
If we want to automatically check for collisions
we must use the name tag “collision” in every object that we want to use
to check collisions. It is recommended to use a tool around 25% bigger than the
calibrated tool for collision checking to safely avoid collisions.
There are four sets of measurements that are required to successfully accomplish robot calibration:
1. Base setup: six measurements (or more) moving axis 1 and 2 are required to place the calibration reference with respect to the robot. Select Show in the calibration settings window and the robot will move along the sequence.
2. Tool setup: seven or more measurements are required to calibrate the tool flange and the tool targets (moving axis 5 and 6). Select Show and the robot will move along the sequence.
3. Calibration measurements: 60 measurements or more are required to calibrate the robot. These measurements can be randomly placed in the robot workspace and free of collision with the surrounding objects.
4. Validation measurements (optional): as many measurements as desired can be used to validate the robot accuracy. These measurements are used only to validate the accuracy of the robot and not to calibrate the robot.
The first two sets of measurements are automatically generated by RoboDK. Select Show and the robot will follow the sequence (as shown in the following images). If the sequence needs to be changed, select Measure and export the calibration measurements as a CSV file by selecting Export data. This file can be edited using an Excel sheet and re-imported by clicking Import data.
Important: The first line of the CSV file must remain untouched.
The last two sets of measurements (calibration and validation) can be generated using the macro script called Create measurements. This macro script is automatically added to the station when we start the robot calibration project. Double click the macro to execute it. This macro is a Python program that guides the user to define the following settings:
● Number of measurements: The number of measurements to generate. By default, 80 measurements are used because a minimum of 60 measurements is required for robot calibration.
● Reference position: The reference position must be a position of the robot where the tool is facing the tracker with visible targets.
● Joint limits: The lower and upper joint limits must be provided.
● Cartesian limits: We can provide Cartesian limits (X,Y,Z values) with respect to the robot reference frame.
The script automatically generates measurements where the tool is facing the tracker as well as respecting the joint and Cartesian constrains. A rotation of +/-180 deg around the tool is permitted around the direction that faces the tracker at the reference position. Furthermore, the sequence of joint movements is free of collision and inside the measurement workspace (if the workspace is set to be visible). The following image shows the summary that is presented to the user before the automatic sequence starts. It may take up to 5 minutes for the sequence to finish.
If desired, we can modify the script by right clicking the Create measurements script and selecting Edit script, then, modify additional parameters of the algorithm. The script automatically saves the user input as station parameters. We can view, edit or delete these settings by right clicking the station and selecting Station parameters, as shown in the next image.
A new message will pop up once the algorithm finishes. We can select “Calibration” to use the 60 measurements for robot calibration. We can re-execute the same script to generate another set of measurements for validation. This step is optional but 80 measurements are recommended for validation purposes.
Finally, it is also possible to import configurations that have been selected manually by selecting Import data (inside the Measure menu). We can import a CSV or a TXT file as an Nx6 matrix, where N is the number of configurations.
It is required to connect the laser tracker and the robot to the computer to automate the procedure of taking measurements. It is also recommended to measure a reference frame through three points in case we move the laser tracker (this step is mandatory if we want to recover the home position for axis 1, see Annex II for more information).
It is required to attach at least one SMR target (three or more is recommended), as shown in the following images. It is also convenient to use 3 nests as a reference frame if the laser tracker must be moved.
The following subsections must be sequentially accomplished to be ready to start taking measurements.
The IP of the laser tracker is needed to properly set the communication with RoboDK. Follow these steps to verify the communication with the laser tracker:
a. Select the menu « Connect➔Connect laser tracker ». A new window should open.
b. Set the IP of the laser tracker.
c. Click the “Connect” button.
If the connection is successful you should see a green message showing “Ready”. The window can be closed and the connection will remain active.
The IP of the robot (or the COM port number for RS232 connections) is needed to properly set the communication with RoboDK. Follow these steps to verify the communication with the robot:
1. Select Connect➔Connect robot. A new window will appear.
2. Set the IP and port of the robot (or the COM port if the connection is through RS232).
3. Click the Connect button.
4. Refer to the appendix if any problems arise.
Note: More information available in the program section.
If the connection is successful you should see a green message displaying Ready. The position of the virtual robot should exactly match the position of the real robot if we select Get current joints. Alternatively, select Move to current joints to move the robot to the current position set in the simulator. The window can be closed and the connection will remain active.
Important: The position of the virtual robot should exactly match the position of the real robot if we select “Get current joints” and “Move to current joints”. Some robot settings may be incorrect if this is not the case.
It is recommended to measure a calibration reference frame, attached to the robot base, this will be helpful if we want to move the tracker during calibration or compare two robot calibrations. The calibration reference frame must be defined by 3 tangible points.
We can skip this step if we are not going to move the tracker with respect to the robot or we do not need to recover the home position for axis 1. In this case, the reference of the laser tracker will be used.
Important: This step is important if we want to recover the home position for axis 1. Refer to the Appendix III for more information.
We should follow these steps every time the laser tracker is moved:
1. Select Connect➔Connect laser tracker.
2. Set the IP of the laser tracker and select connect (if laser tracker is not connected).
3. Set the calibration reference and the tracker reference as shown in the image. The calibration reference is also known as “Measurements reference”.
4. Select Set Base targets.
RoboDK will guide the user with the menus shown in the next image. The position of the laser tracker will be updated automatically with respect to the calibration reference when the procedure is completed.
Robot calibration is divided in 4 steps. Each step requires taking a set of measurements. These four steps must be followed in order:
1. Base reference measurements (3 minutes).
2. Tool reference measurements (3 minutes)
3. Calibration measurements (7 minutes, 60 measurements)
4. Validation measurements (7 minutes, 60 measurements).
The following video shows how to perform this calibration in 20 minutes: https://www.robodk.com/robot-calibration#tab-lt. The validation measurements (step 4) are not mandatory to calibrate the robot, however they provide an objective point of view of the accuracy results. It is also possible to see the impact of calibrating the robot in one area and validating it in a different area.
Select the button Measure for each of the four sets of measurements. This will open a new window that allows taking new measurements as well as import and export existing measurements in a text file (csv or txt format).
These measurements can be performed anywhere in the tool flange if we measure the same target for all the 6 measurements. To start the measurements, select Measure in the Base setup section. The following window will open. Then, select Start Measure and the robot will move sequentially through the scheduled measurements.
Tip: Double click a measurement to continue measuring from that position.
Close the window when the measurements are completed and the Measurements reference frame will be updated with respect to the robot base frame. If we did not select any reference frame, we can add a reference (select Program➔Add Reference Frame) and place it under the robot base reference (Drag & Drop in the item tree).
The summary will show the position and orientation or the robot reference frame with respect to the calibration reference frame ([x,y,z,w,p,r] format in mm and radians)
Measurements 1-6 can be performed anywhere in the tool flange as long as we measure the same target for the 6 measurements. After that, every TCP that we want to measure will add one measurement for the same TCP, in this case, we have 3 TCPs so 6+3=9 measurements in total. We can double click a measurement to continue measuring from that position.
Like the previous section: select Measure in the Tool setup section. The following window will open. Select Start Measure and the robot will move sequentially through the planned measurements. Double click a measurement to continue measuring from that position.
The summary will show the calibrated TCPs when the procedure is completed. The definition of the TCP (in the following image “CalibTool 1”) will be updated automatically. If we did not select any TCP, we can add a new one (select “Program➔Add empty Tool”) and select “Recalculate”. A new window will appear and we must select the “id” of the tool depending on the order that we took the measurements. We can repeat the same procedure to update as many TCPs as we need (in this case 3 TCPs). The id of the tool will be automatically detected if the name of the tool ends with a number.
Select Measure in the Calibration section. The following window will open. Then, select Start Measure and the robot will move sequentially through the planned measurements. Double click a measurement to continue measuring from that position.
Close the window when the measurements are completed. The robot will be calibrated automatically and it will display the following message if there are no issues.
Finally, the green screen will display some statistics regarding the calibration measurements and how much the accuracy is improved for those measurements.
We shouldn’t validate the accuracy of the robot using the same measurements that we used to calibrate the robot, therefore, it is recommended to take additional measurements to validate the accuracy (having a more objective point of view of the accuracy results).
The same calibration procedure must be
followed to take the validation measurements. The summary will display the
validation statistics. See the following Results Section
for more information.
Once the calibration is completed we can analyze the accuracy improvement by reading the statistics provided by RoboDK. To display these statistics, open the robot calibration window (double click the icon Robot Calibration). The summary window in the validation section will display the errors before calibration (nominal kinematics) and after calibration (calibrated kinematics). Two tables are provided, one shows statistics concerning position errors and the other one shows distance errors:
● Position errors: The position error is the accuracy that the robot can attain one point with respect to a reference frame.
● Distance errors: The distance error is obtained by measuring the distance error of pairs of points. The distance between two points seen by the robot (obtained using the calibrated kinematics) is compared with the distance seen by the measurement system (physically measured). All combinations are taken into account. If we took 315 measurements we will have 315x315/2= 49455 distance error values.
The statistics provided are the mean error, the standard deviation (std) and the maximum error. It is also provided the mean plus three times the standard deviation, which corresponds to the expected error for 99.98% of all the measurements (if we take into account that errors follow a normal distribution).
Select Show stats and two histograms will show the distribution of the errors before and after calibration, one histogram for position accuracy and the other showing distance accuracy. The following images correspond to the 315 validation measurements used in this example.
Finally, we can select Make report
and a PDF report with the information presented in this section will be
Once the robot has been calibrated, we have two options to generate programs using the absolute accuracy of the calibrated robot:
● Filter existing programs: all the robot targets inside a program are modified to improve the accuracy of the robot. It can be done manually or using the API.
● Use RoboDK for Offline Programming to generate accurate programs (generated programs are already filtered, including programs generated using the API).
To filter an existing program manually: drag & drop the robot program file into RoboDK’s main screen (or select File➔Open) and select Filter only. The program will be filtered and saved in the same folder. The filter summary will mention if there were any problems using the filtering algorithm. We also have the option to import a program if we want to simulate it inside RoboDK. If the program has any dependencies (tool frame or base frame definitions, subprograms, ...) they must be located in the same directory where the first program is imported.
Once we import the program inside RoboDK we can regenerate it with or without absolute accuracy. In the main accuracy settings of RoboDK (Tools➔Options➔Accuracy) we can decide if we want to always generate the programs using accurate kinematics, if we want to ask every time or if we want to use the current robot kinematics. The current robot kinematics can be changed by right clicking the robot and activating/deactivating the “Use accurate kinematics” tag. If it is active we will see a green dot, if it is not active, we will see a red dot.
It is possible to filter a complete program using RoboDK given a calibrated robot and the robot program using the FilterProgram call:
A macro example called FilterProgram is available in the Macros section of the library. The following code is an example Python script that uses the RoboDK API to filter a program.
from robolink import * # API to communicate with RoboDK
from robodk import * # basic matrix operations
import os # Path operations
# Get the current working directory
CWD = os.path.dirname(os.path.realpath(__file__))
# Start RoboDK if it is not running and link to the API
RDK = Robolink()
# optional: provide the following arguments to run behind the scenes
#RDK = Robolink(args='/NOSPLASH /NOSHOW /HIDDEN')
# Get the calibrated station (.rdk file) or robot file (.robot):
# Tip: after calibration, right click a robot and select "Save as .robot"
calibration_file = CWD + '/KUKA-KR6.rdk'
# Get the program file:
file_program = CWD + '/Prog1.src'
# Load the RDK file or the robot file:
calib_item = RDK.AddFile(calibration_file)
if not calib_item.Valid():
raise Exception("Something went wrong loading " + calibration_file)
# Retrieve the robot (no popup if there is only one robot):
robot = RDK.ItemUserPick('Select a robot to filter', ITEM_TYPE_ROBOT)
if not robot.Valid():
raise Exception("Robot not selected or not available")
# Activate accuracy
# Filter program: this will automatically save a program copy
# with a renamed file depending on the robot brand
status, summary = robot.FilterProgram(file_program)
if status == 0:
print("Program filtering succeeded")
print("Program filtering failed! Error code: %i" % status)
The following code is an example Python script that uses the RoboDK API to filter a target (pose target or joint target), using the FilterTarget command:
pose_filt, joints = robot.FilterTarget(nominal_pose, estimated_joints)
This example is useful if a 3rd party application (other than RoboDK) generates the robot program using pose targets.
Note: This is not required if programs are generated automatically using the API.
from robolink import * # API to communicate with RoboDK
from robodk import * # basic matrix operations
return KUKA_2_Pose(xyzwpr) # Convert X,Y,Z,A,B,C to a pose
return Pose_2_KUKA(pose) # Convert a pose to X,Y,Z,A,B,C
# Start the RoboDK API and retrieve the robot:
RDK = Robolink()
robot = RDK.Item('', ITEM_TYPE_ROBOT)
if not robot.Valid():
raise Exception("Robot not available")
pose_tcp = XYZWPR_2_Pose([0, 0, 200, 0, 0, 0]) # Define the TCP
pose_ref = XYZWPR_2_Pose([400, 0, 0, 0, 0, 0]) # Define the Ref Frame
# Update the robot TCP and reference frame
# Very important for SolveFK and SolveIK (Forward/Inverse kinematics)
robot.setAccuracyActive(False) # Accuracy can be ON or OFF
# Define a nominal target in the joint space:
joints = [0, 0, 90, 0, 90, 0]
# Calculate the nominal robot position for the joint target:
pose_rob = robot.SolveFK(joints) # robot flange wrt the robot base
# Calculate pose_target: the TCP with respect to the reference frame
pose_target = invH(pose_ref)*pose_rob*pose_tcp
print('Target not filtered:')
joints_approx = joints # joints_approx must be within 20 deg
pose_target_filt, real_joints = robot.FilterTarget(pose_target, joints)
Once the robot has been calibrated, we usually need RoboDK to filter programs, therefore, a RoboDK license is required (a basic OLP license is enough for generating accurate robot programs once the robot has been calibrated). Filtering a program means that the targets in a program are altered/optimized to improve the accuracy of the robot, taking into account all the calibration parameters (about 30 parameters).
Alternatively, we can calibrate only the joint offsets plus the base and tool reference frames (4 joint offset parameters plus 6 parameters for the base frame plus 6 parameters for the tool frame). The calibration will not be as accurate as if we used the default complete calibration but it might allow entering certain parameters in the robot controller and not depend on RoboDK to generate robot programs.
To obtain the calibration only for the joint offsets we must select the Calib. Param. button, then the Mastering button (inside the robot calibration menu).
A new window will appear after we select Make mastering program. In this window we can select what axes we want to consider creating the new home position.
The button Make mastering program will appear in the robot calibration window. Select this button to generate a program that will bring the robot to the new home position. Transfer it to the robot and execute it, then, the new home position must be recorded.
Important: Recovering the home position for axis 1 and axis 6 requires special attention, more information available in the Appendix.
If the robot and the PC are connected, we can right click the program and select Send Program to Robot to automatically send the program to the robot. Otherwise, we can select Generate robot program to see new joint values for the home position.
Important: If we change the mastering parameters of a robot (home position) and we still want to use a complete calibration (filter programs), we must take the calibration measurements again (and validation, if any) and recalibrate. In this case, we can use RoboDK to filter programs or generate programs from scratch (through CAM files: APT, G-code, …).
As an example, we must follow the next steps to update home position for Motoman robots.
Important: We should not run this procedure twice. Otherwise we will be setting a different home position.
We must first run the program “MASTERING” to bring the robot to the new home position.
Once the program is in the controller we must log in as “Management mode” (password for Motoman robots is usually 99999999) and we need to be in Teach mode. The following images show the steps that must be followed.
Make sure to update the home position for all robot joints.
Once the home position is set, we must delete the robot program that brought the robot to the new home position.
should not execute this procedure twice.
RoboDK provides some utilities to calibrate reference frames and tool frames. These tools can be accessed from Utilities➔Calibrate Reference frame and Utilities➔Calibrate Tool frame respectively.
To calibrate a reference frame or a tool frame (also known as User frame and TCP respectively) we need some robot configurations touching 3 or more points, these robot configurations can either be joint values or Cartesian coordinates (with orientation data in some cases). It is recommended to use the joint values instead of the Cartesian coordinates as it is easier to check the real robot configuration in RoboDK (by copy-pasting the robot joints to the RoboDK main screen).
the robot is calibrated, it is strongly recommended to use the joint values
instead of the Cartesian coordinates. If we use the joint values, the accuracy
of the robot is taken into account to teach the TCP more accurately.
Select Utilities➔Calibrate tool to calibrate the TCP using RoboDK. We can use as many points as desired, using different orientations. More points and larger orientation changes is better as we will get a better estimate of the TCP as well as a good estimate of the TCP error.
Note: More information available in the tips section.
The following two options are available to calibrate a TCP:
● By touching one stationary point with the TCP with different orientations.
● By touching a plane with the TCP (like a touch probe).
It is recommended to calibrate by touching a plane reference if we have to calibrate a touch probe or a spindle. This method is more stable against user errors.
If the TCP is spherical, the center of the sphere is calculated as the new TCP (it is not necessary to provide the sphere diameter).
The following steps must be followed to calibrate the TCP with a plane (as seen in the picture):
1. Select the tool that needs to be calibrated.
2. Select the calibration method➔”Calib XYZ by plane”.
3. Select calibrate using “joints”.
4. Select the robot that is being used.
5. Select the number of configurations that we will use for TCP calibration (it is recommended to take 8 configurations or more).
6. Select an estimate of the reference plane. If the reference plane is not parallel to the robot XY plane (from the robot reference) we must add an estimate of this reference plane within ±20 degrees. The position of this plane is not important, only the orientation.
7. We can start filling the table of joint values. We can fill it manually or by doing copy/paste with the buttons (as shown in the image). We can also use the button “Get Jx” to get the current joint values from the robot in the simulator. If we are getting the joints from a real robot connected to the robot we must first select “Get current joints” from the robot connection menu (see image attached or the appendix for more information about connecting a robot with RoboDK). It is strongly recommended to keep a separate copy of the joints used for calibration (such as a text file, for example).
8. Once the table is filled we will see the new TCP values (X,Y,Z) as the “Calibrated TCP”, towards the end of the window. We can select “Update” and the new TCP will be updated in the RoboDK station. The orientation of the probe cannot be found using this method.
9. We can select “Show errors” and we will see the error of every configuration with respect to the calculated TCP (which is the average of all the configurations). We can delete one configuration if it has a larger error than the others.
We must manually update the values in the real
robot controller (X,Y,Z only). If this TCP will be used in a program generated
by RoboDK, it is not necessary to update the values in the robot controller.
Select Utilities➔Calibrate reference to calibrate a reference frame. It is possible to set a reference frame using different methods. In the example of the figure, a reference frame is defined by three points: point 1 and 2 define the X axis direction and point 3 defines the positive Y axis.
Important: It is recommended to use joint targets and activate robot accuracy before calibrating the reference frame as the accuracy of the robot arm will help better defining the reference frame.
information available regarding reference frame calibration in the tips section.
We must pay special attention if we want to recover the mastering/home values for axes 1 and 6. These values are directly related to the robot base frame for the axis 1 and a TCP reference for axis 6. Therefore, external measurements must be taken to properly set these values. This window appears after we select “Make mastering program” in the calibration menu.
The next two procedures must be followed to properly set the mastering parameters for these two axes.
We must use a reference target to properly set the “home” position of axis 6. The angle offset will be the rotation around the Z axis of the tool flange needed to best fit the measured TCP (X,Y,Z) with the known TCP reference. The measured TCP (see the following image) is one of the TCPs that were measured in the step two of the calibration procedure. The reference TCP is a known reference that corresponds to one of the TCP for the calibration tool being used.
Ideally, the reference TCP must be measured by the CMM with respect to the tool flange (a replica of the robot tool flange would be best). Alternatively, we can use a new robot to measure (step two of the calibration procedure) the TCP for the first time and use one measured TCP as the reference. It is important to use a dowel pin and/or appropriate tool flange referencing to make sure that the end effector is always placed at the same position.
We must properly measure three base targets before starting a robot calibration if we want to align the axis 1 with the real robot base frame. These base targets must be chosen so that the reference frame can be found with respect to the robot.
The “home” position of axis 1 directly depends on the three base targets as well as the robot base setup. The robot base setup is the first calibration step, where the base frame of the measurement system is placed with respect to the robot base frame by moving and measuring axis 1 and 2.
The base targets of the measurement system can be set by pressing “Set base targets” (see following image). These are 3 measurements that will define the desired robot reference frame (the first 2 measurements define the X axis and the third point the positive Y axis). We should use appropriate reference points related to the robot base so that this procedure is repeatable.
The correction angle for joint 1 will be the angle between the X axis of the base reference measured through 3 points and the base reference measured by moving the robot axes 1 and 2. Of course, both vectors are previously projected to the XY plane of the base reference obtained by touching the tree points.
Robot calibration requires measurements to be taken from the robot with a measurement system. To take these measurements it is required a Faro laser tracker that communicates with a computer. The communication is done through a driver exe file that can be run in console mode.
For example, Faro provides a free application called “Tracker Utilities”. This application can initialize the laser tracker and perform some health checks, among other things.
To initialize the tracker we should start the “Tracker Utilities” application, connect using the tracker IP, then, select “Startup Checks”. When the tracker initializes, we should place a 1.5’’ SMR target in the “home” position before initialization. Otherwise, the green light will flash after initialization and the measurements will not be valid.
Once the initialization is done we should read the “Startup complete” message, as shown in the following image.
If we experience problems with the tracker, we can run some health checks by pressing “Health Checks…”. The next two images show a success check and a failed check respectively. Sometimes, problems are solved after reconnecting the cables and rebooting the laser tracker.
Note: It is recommended to perform a tracker Self compensation from time to time. This compensation uses some reference points in the tracker head to auto calibrate the measurement system. Alternatively, we can run some angular Accuracy Checks to validate the accuracy of the laser tracker.
Finally, we can use the “Measure pad” to take some measurements. The laser tracker can follow a target and measure the XYZ position at a rate of 1000 Hz. If we set 1 sample per point and continuous trigger the tracker will record 1000 measurements per second in a CSV file.
We can use this feature to measure a robot path and use the RoboDK’s path accuracy check to check the accuracy, speed and acceleration along the path.