The URScript Programming Language

The URScript Programming Language
Version 1.7
February 1, 2013
The information contained herein is the property of Universal Robots A/S and shall
not be reproduced in whole or in part without prior written approval of Universal
Robots A/S. The information herein is subject to change without notice and should not
be construed as a commitment by Universal Robots A/S. This manual is periodically
reviewed and revised.
Universal Robots A/S assumes no responsibility for any errors or omissions in this
document.
c
Copyright 2012
by Universal Robots A/S
The Universal Robots logo is a registered trademark of Universal Robots A/S.
URScript
CONTENTS
CONTENTS
Contents
Contents
1 The URScript Programming Language
1.1 Introduction . . . . . . . . . . . .
1.2 Connecting to URControl . . . .
1.3 Numbers, Variables and Types .
1.4 Flow of Control . . . . . . . . . .
1.5 Function . . . . . . . . . . . . . .
1.6 Scoping rules . . . . . . . . . . .
1.7 Threads . . . . . . . . . . . . . . .
1.7.1 Threads and scope . . . .
1.7.2 Thread scheduling . . . .
1.8 Program Label Messages . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4
4
4
4
5
5
6
7
8
9
9
2 Module motion
9
2.1 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3 Module internals
15
3.1 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.2 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4 Module urmath
20
4.1 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.2 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
5 Module interfaces
28
5.1 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
5.2 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
URScript
1.1
Introduction
The Universal Robot can be controlled a three different levels: The Graphical UserInterface Level, the Script Level and the C-API Level. URScript is the robot programming
languange used to control the robot at the Script Level. Like any other programming
language URScript has variables, types, flow of control statements, function etc. In
addition URScript has a number of built-in variables and functions which monitors and
controls the I/O and the movements of the robot.
1.2
Connecting to URControl
URControl is the low-level robot controller running on the Mini-ITX PC in the controller
cabinet. When the PC boots up URControl starts up as a daemon (like a service) and
PolyScope User Interface connects as a client using a local TCP/IP connection.
Programming a robot at the Script Level is done by writing a client application (running
at another PC) and connecting to URControl using a TCP/IP socket.
hostname: ur-xx (or the ip-adresse found in the about dialog-box in PolyScope if
the robot is not in dns.)
port: 30002
When connected URScript programs or commands are sent i clear text on the socket.
Each line is terminated by \n.
1.3
Numbers, Variables and Types
The syntax of arithmetic expressions in URScript is very standard:

1+2-3
4*5/6
(1+2)*3/(4-5)
In boolean expressions the boolean operators are spelled out:
True or False and (1 == 2)
1 > 2 or 3 != 4 xor 5 < -6
not 42 >= 87 and 87 <= 42
Variable assignment is done using the equal sign =:
foo =
bar =
baz =
hello
42
False or True and not False
87-13/3.1415
= "Hello, World!"
4
URScript
Flow of Control
l = [1,2,4]
target = p[0.4,0.4,0.0,0.0,3.14159,0.0]
The fundamental type of a variable is deduced from the first assignment of the variable. In the example above foo is an int and bar is a bool. target is a pose, a
combination of a position and orientation.
The fundamental types are:
none
bool
number - either int or float
pose
string
A pose is given as p[x,y,z,ax,ay,az], where x,y,z is the position of the TCP, and
ax,ay,az is the orientation of the TCP, given in axis-angle notation.
1.4
Flow of Control
The flow of control of a program is changed by if-statements:

if a > 3:
a = a + 1
elif b < 7:
b = b * a
else:
a = a + b
end
and while-loops:
l = [1,2,3,4,5]
i = 0
while i < 5:
l[i] = l[i]*2
end
To stop a loop prematurely the break statement can be used. Similarly the continue
statement can be used to pass control to the next iteration of the nearest enclosing
loop.
1.5
Function
A function is declared as follows:
URScript
Scoping rules
def add(a, b):

return a+b
end
The function can then be called like this:
result = add(1, 4)
It is also possible to give function arguments default values:
def add(a=0,b=0):
return a+b
end
URScript also supports named parameters. These will not be described here, as the
implementation is still somewhat broken.
1.6
Scoping rules
A urscript program is declared as a function without parameters:

def myProg():
end
Every variable declared inside a program exits at a global scope, except when they
are declared inside a function. I that case the variable are local to that function. Two
qualifiers are available to modify this behaviour. The local qualifier tells the runtime to
treat a variable inside a function, as being truly local, even if a global variable with the
same name exists. The global qualifier forces a variable declared inside a function,
to be globally accessible.
In the following example, a is a global variable, so the variable inside the function is
the same variable declared in the program:
def myProg():
a = 0
def myFun():
a = 1
return a
end
r = myFun()
end
In this next example, a is declared local inside the function, so the two variables are
different, even though they have the same name:
def myProg():
6
URScript
Threads
a = 0
def myFun():
local a = 1
return a
end
r = myFun()
end
Beware that the global variable is no longer accessible from within the function, as the
local variable masks the global variable of the same name.
1.7
Threads
Threads are supported by a number of special commands.

To declare a new thread a syntax similar to the declaration of functions are used:
thread myThread():
# Do some stuff
return
end
A couple of things should be noted. First of all, a thread cannot take any parameters,
and so the parentheses in the declaration must be empty. Second, although a return
statement is allowed in the thread, the value returned is discarded, and cannot be
accessed from outside the thread. A thread can contain other threads, the same
way a function can contain other functions. Threads can in other words be nested,
allowing for a thread hierarchy to be formed.
To run a thread use the following syntax:
thread myThread():
# Do some stuff
return
end
thrd = run myThread()
The value returned by the run command is a handle to the running thread. This handle
can be used to interact with a running thread. The run command spawns off the new
thread, and then goes off to execute the instruction following the run instruction.
To wait for a running thread to finish, use the join command:
7
URScript
Threads
thread myThread():
# Do some stuff
return
end
join thrd
This halts the calling threads execution, until the thread is finished
executing. If the thread is already finished, the statement has no effect.
To kill a running thread, use the kill command:
thread myThread():
# Do some stuff
return
end
kill thrd
After the call to kill, the thread is stopped, and the thread handle is no longer valid. If
the thread has children, these are killed as well.
To protect against race conditions and other thread related issues, support for critical
sections are provided. A critical section ensures that the code it encloses is allow to
finish, before another thread is allowed to run. It is therefore important that the critical
section is kept as short as possible. The syntax is as follows:
thread myThread():
enter_critical
# Do some stuff
exit_critical
return
end
1.7.1
Threads and scope
The scoping rules for threads are exactly the same, as those used for functions. See
section 1.6 for a discussion of these rules.
URScript
Program Label Messages
1.7.2
Module motion
Thread scheduling
Because the primary purpose of the urscript scripting language is to control the robot,
the scheduling policy is largely based upon the realtime demands of this task.
The robot must be controlled a frequency of 125 Hz, or in other words, it must be told
what to do every 0.008 second (each 0.008 second period is called a frame). To
achieve this, each thread is given a physical (or robot) time slice of 0.008 seconds
to use, and all threads in a runnable state is then scheduled in a round robin1 fashion.
Each time a thread is scheduled, it can use a piece of its time slice (by executing
instructions that control the robot), or it can execute instructions that doesnt control
the robot, and therefor doesnt use any physical time. If a thread uses up its entire
time slice, it is placed in a non-runnable state, and is not allowed to run until the next
frame starts. If a thread does not use its time slice within a frame, it is expected to
switch to a non-runnable state before the end of the frame2 . The reason for this state
switching can be a join instruction or simply because the thread terminates.
It should be noted, that even though the sleep instruction doesnt control the robot,
it still uses physical time. The same is true for the sync instruction.
1.8
Program Label Messages
A special feature is added to the script code, to make it simple to keep track of which
lines are executed by the runtime machine. An example Program Label Message in
the script code looks as follows;
sleep(0.5)
$ 3 "AfterSleep"
digital_out[9] = True
After the the Runtime Machnie executes the sleep command, it will send a message
of type PROGRAM LABEL to the latest connected primary client. The message will hold
the number 3 and the text AfterSleep. This way the connected client can keep track
of which lines of codes are being executed by the Runtime Machine.
Module motion
This module contains functions and variables built into the URScript programming language.
URScript programs are executed in real-time in the URControl RuntimeMachine (RTMachine). The RuntimeMachine communicates with the robot with a frequency of 125hz.
1
Before the start of each frame the threads are sorted, such that the thread with the largest remaining
time slice is to be scheduled first.
2
If this expectation is not met, the program is stopped.
URScript
Functions
Module motion
Robot trajectories are generated online by calling the move functions movej, movel
and the speed functions speedj, speedl and speedj init.
Joint positions (q) and joint speeds (qd) are represented directly as lists of 6 Floats,
one for each robot joint. Tool poses (x) are represented as poses also consisting of 6
Floats. In a pose, the first 3 coordinates is a position vector and the last 3 an axis-angle
(http://en.wikipedia.org/wiki/Axis angle).
2.1
Functions
end force mode()
Resets the robot mode from force mode to normal operation.
This is also done when a program stops.
10
URScript
Functions
Module motion
force mode(task frame, selection vector, wrench, type, limits)

Set robot to be controlled in force mode
Parameters
task frame:
A pose vector that defines the force

frame relative to the base frame.
selection vector: A 6d vector that may only contain 0 or 1.

1 means that the robot will be compliant
in the corresponding axis of the task
frame, 0 means the robot is not
compliant along/about that axis.
wrench:
The forces/torques the robot is to apply

to its environment. These values have
different meanings whether they
correspond to a compliant axis or not.
Compliant axis: The robot will adjust its
position along/about the axis in order to
achieve the specified force/torque.
Non-compliant axis: The robot follows
the trajectory of the program but will
account for an external force/torque of
the specified value.
type:
An integer specifying how the robot

interprets the force frame. 1: The force
frame is transformed in a way such that
its y-axis is aligned with a vector pointing
from the robot tcp towards the origin of
the force frame. 2: The force frame is not
transformed. 3: The force frame is
transformed in a way such that its x-axis is
the projection of the robot tcp velocity
vector onto the x-y plane of the force
frame. All other values of type are
invalid.
limits:
A 6d vector with float values that are

interpreted differently for
compliant/non-compliant axes:
Compliant axes: The limit values for
compliant axes are the maximum
allowed tcp speed along/about the axis.
Non-compliant axes: The limit values for
non-compliant axes are the maximum
allowed deviation along/about an axis
between the actual tcp position and the
one set by the program.
11
URScript
Functions
Module motion
movec(pose via, pose to, a=1.2, v=0.3, r=0)

Move Circular: Move to position (circular in tool-space)
TCP moves on the circular arc segment from current pose, through
pose via to pose to. Accelerates to and moves with constant tool speed
v.
Parameters
pose via: path point (note: only position is used). (pose via
can also be specified as joint positions, then
forward kinematics is used to calculate the
corresponding pose)
pose to:
target pose (pose to can also be specified as joint

positions, then forward kinematics is used to
calculate the corresponding pose)
a:
tool acceleration [m/s2]
v:
tool speed [m/s]
r:
blend radius (of target pose) [m]
movej(q, a=3, v=0.75, t=0, r=0)

Move to position (linear in joint-space) When using this command, the
robot must be at standstill or come from a movej og movel with a blend.
The speed and acceleration parameters controls the trapezoid speed
profile of the move. The $t$ parameters can be used in stead to set the
time for this move. Time setting has priority over speed and acceleration
settings. The blend radius can be set with the $r$ parameters, to avoid
the robot stopping at the point. However, if he blend region of this mover
overlaps with previous or following regions, this move will be skipped, and
an Overlapping Blends warning message will be generated.
Parameters
q: joint positions (q can also be specified as a pose, then
inverse kinematics is used to calculate the corresponding
joint positions)
a: joint acceleration of leading axis [rad/s2]
v: joint speed of leading axis [rad/s]
t: time [S]
r: blend radius [m]
12
URScript
Functions
Module motion
movel(pose, a=1.2, v=0.3, t=0, r=0)

Move to position (linear in tool-space)
See movej.
Parameters
pose: target pose (pose can also be specified as joint
positions, then forward kinematics is used to calculate
the corresponding pose)
a:
v:
tool speed [m/s]
t:
time [S]
r:
blend radius [m]
movep(pose, a=1.2, v=0.3, r=0)

Move Process
Blend circular (in tool-space) and move linear (in tool-space) to position.
Accelerates to and moves with constant tool speed v.
Parameters
a:
v:
tool speed [m/s]
r:
blend radius [m]
servoc(pose, a=1.2, v=0.3, r=0)

Servo Circular
Servo to position (circular in tool-space). Accelerates to and moves with
constant tool speed v.
Parameters
a:
v:
tool speed [m/s]
r:
blend radius (of target pose) [m]
13
URScript
Functions
Module motion
servoj(q, a=3, v=0.75, t=0)

Servo to position (linear in joint-space)
Parameters
q: joint positions
a: NOT used in current version
v: NOT used in current version
t: time [S]
set pos(q)
Set joint positions of simulated robot
Parameters
q: joint positions
speedj(qd, a, t min)
Joint speed
Accelerate to and move with constant joint speed
Parameters
qd:
a:
joint speeds [rad/s]

joint acceleration [rad/s2] (of leading axis)
t min: minimal time before function returns

speedj init(qd, a, t min)
Joint speed (when robot is in ROBOT INITIALIZING MODE)
Accelerate to and move with constant joint speed
Parameters
qd:
a:
joint speeds [rad/s]

joint acceleration [rad/s2] (of leading axis)

speedl(xd, a, t min)
Tool speed
Accelerate to and move with constant tool speed
http://axiom.anu.edu.au/roy/spatial/index.html
Parameters
xd:
a:
tool speed [m/s] (spatial vector)

tool acceleration [/s2]

14
URScript
Module internals
stopj(a)
Stop (linear in joint space)
Decellerate joint speeds to zero
Parameters
a: joint acceleration [rad/s2] (of leading axis)
stopl(a)
Stop (linear in tool space)
Decellerate tool speed to zero
Parameters
a: tool accleration [m/s2]
2.2
Variables
Name
package
a joint default
a tool default
v joint default
v tool default
3
3.1
Value:
Value:
Value:
Value:
Value:
Description
Motion
3
1.2
0.75
0.3
Module internals
Functions
get actual joint positions()
Returns the actual angular positions of all joints
The angular actual positions are expressed in radians and returned as a
vector of length 6. Note that the output might differ from the output of
get target joint positions(), especially durring acceleration and heavy
loads.
Return Value
The current actual joint angular position vector in rad : [Base,
Shoulder, Elbow, Wrist1, Wrist2, Wrist3]
15
URScript
Functions
Module internals
get actual joint speeds()

Returns the actual angular velocities of all joints
The angular actual velocities are expressed in radians pr. second and
returned as a vector of length 6. Note that the output might differ from
the output of get target joint speeds(), especially durring acceleration
and heavy loads.
Return Value
The current actual joint angular velocity vector in rad/s: [Base,
get actual tcp pose()
Returns the current measured tool pose
Returns the 6d pose representing the tool position and orientation
specified in the base frame. The calculation of this pose is based on the
actual robot encoder readings.
Return Value
The current actual TCP vector : ([X, Y, Z, Rx, Ry, Rz])
get actual tcp speed()
Returns the current measured TCP speed
The speed of the TCP retuned in a pose structure. The first three values
are the cartesian speeds along x,y,z, and the last three define the current
rotation axis, rx,ry,rz, and the length |rz,ry,rz| defines the angular velocity in
radians/s.
Return Value
The current actual TCP velocity vector; ([X, Y, Z, Rx, Ry, Rz])
get controller temp()
Returns the temperature of the control box
The temperature of the robot control box in degrees Celcius.
Return Value
A temperature in degrees Celcius (float)
16
URScript
Functions
Module internals
get inverse kin(x)

Inverse kinematics
Inverse kinematic transformation (tool space -> joint space). Solution
closest to current joint positions is returned
Parameters
x: tool pose (spatial vector)
Return Value
joint positions
get joint temp(j)
Returns the temperature of joint j
The temperature of the joint house of joint j, counting from zero. j=0 is the
base joint, and j=5 is the last joint before the tool flange.
Parameters
j: The joint number (int)
Return Value
A temperature in degrees Celcius (float)
get joint torques()
Returns the torques of all joints
The torque on the joints, corrected by the torque needed to move the
robot itself (gravity, friction, etc.), returned as a vector of length 6.
Return Value
The joint torque vector in ; ([float])
get target joint positions()
Returns the desired angular position of all joints
The angular target positions are expressed in radians and returned as a
vector of length 6. Note that the output might differ from the output of
get actual joint positions(), especially durring acceleration and heavy
loads.
Return Value
The current target joint angular position vector in rad: [Base,
17
URScript
Functions
Module internals
get target joint speeds()

Returns the desired angular velocities of all joints
The angular target velocities are expressed in radians pr. second and
returned as a vector of length 6. Note that the output might differ from
the output of get actual joint speeds(), especially durring acceleration
and heavy loads.
Return Value
The current target joint angular velocity vector in rad/s: [Base,
get target tcp pose()
Returns the current target tool pose
Returns the 6d pose representing the tool position and orientation
specified in the base frame. The calculation of this pose is based on the
current target joint positions.
Return Value
The current target TCP vector; ([X, Y, Z, Rx, Ry, Rz])
get target tcp speed()
Returns the current target TCP speed
The desired speed of the TCP retuned in a pose structure. The first three
values are the cartesian speeds along x,y,z, and the last three define the
current rotation axis, rx,ry,rz, and the length |rz,ry,rz| defines the angular
velocity in radians/s.
Return Value
The TCP speed; (pose)
popup(s, title=Popup, warning=False, error=False)
Display popup on GUI
Display message in popup window on GUI.
Parameters
s:
title:
message string
title string
warning: warning message?

error:
error message?
powerdown()
Shutdown the robot, and power off the robot and controller.
18
URScript
Functions
Module internals
set gravity(d)
Set the direction of the gravity
Parameters
d: 3D vector, describing the direction of the gravity, relative to
the base of the robot.
set payload(m, CoG)
Set payload mass and center of gravity
Sets the mass and center of gravity (abbr. CoG) of the payload.
This function must be called, when the payload weight or weigh
distribution changes significantly - I.e when the robot picks up or puts
down a heavy workpiece.
The CoG argument is optional - If not provided, the Tool Center Point
(TCP) will be used as the Center of Gravity (CoG). If the CoG argument is
omitted, later calls to set tcp(pose) will change CoG to the new TCP.
The CoG is specified as a Vector, [CoGx, CoGy, CoGz], displacement,
from the toolmount.
Parameters
m:
mass in kilograms
CoG: Center of Gravity: [CoGx, CoGy, CoGz] in meters.
Optional.
set tcp(pose)
Set the Tool Center Point
Sets the transformation from the output flange coordinate system to the
TCP as a pose.
Parameters
pose: A pose describing the transformation.
sleep(t)
Sleep for an amount of time
Parameters
t: time [s]
sync()
Uses up the remaining physical time a thread has in the current frame.
19
URScript
Module urmath
textmsg(s)
Send text message
Send message to be shown on the GUI log-tab
Parameters
s: message string, variables of other types (int, bool poses
etc.) can also be sent
3.2
Variables
Name
package
4
4.1
Description
Value: None
Module urmath
Functions
acos(f )
Returns the arc cosine of f
Returns the principal value of the arc cosine of f, expressed in radians. A
runtime error is raised if f lies outside the range [-1, 1].
Parameters
f: floating point value
Return Value
the arc cosine of f.
asin(f )
Returns the arc sine of f
Returns the principal value of the arc sine of f, expressed in radians. A
runtime error is raised if f lies outside the range [-1, 1].
Parameters
Return Value
the arc sine of f.
20
URScript
Functions
Module urmath
atan(f )
Returns the arc tangent of f
Returns the principal value of the arc tangent of f, expressed in radians.
Parameters
Return Value
the arc tangent of f.
atan2(x, y)
Returns the arc tangent of x/y
Returns the principal value of the arc tangent of x/y, expressed in radians.
To compute the value, the function uses the sign of both arguments to
determine the quadrant.
Parameters
x: floating point value
y: floating point value
Return Value
the arc tangent of x/y.
binary list to integer(l)
Returns the value represented by the content of list l
Returns the integer value represented by the bools contained in the list l
when evaluated as a signed binary number.
Parameters
l: The list of bools to be converted to an integer. The bool at
index 0 is evaluated as the least significant bit. False
represents a zero and True represents a one. If the list is
empty this function returns 0. If the list contains more than
32 bools, the function returns the signed integer value of
the first 32 bools in the list.
Return Value
The integer value of the binary list content.
21
URScript
Functions
Module urmath
ceil(f )
Returns the smallest integer value that is not less than f
Rounds floating point number to the smallest integer no greater than f.
Parameters
Return Value
rounded integer
cos(f )
Returns the cosine of f
Returns the cosine of an angle of f radians.
Parameters
Return Value
the cosine of f.
d2r(d)
Returns degrees-to-radians of d
Returns the radian value of d degrees. Actually: (d/180)*MATH PI
Parameters
d: The angle in degrees
Return Value
The angle in radians
floor(f )
Returns largest integer not greater than f
Rounds floating point number to the largest integer no greater than f.
Parameters
Return Value
rounded integer
force()
Returns the force exceted at the TCP
Return the current externally excerted force at the TCP. The force is the
lengt of the force vector calculated using get tcp force().
Return Value
The force in newtons (float)
22
URScript
Functions
Module urmath
get list length(v)

Returns the length of a list variable
The length of a list is the number of entries the list is composed of.
Parameters
v: A list variable
Return Value
An integer specifying the length of the given list
get tcp force()
Returns the force twist at the TCP
The force twist is computet baed on the error between the joint torques
required to stay on the trajectory, and the expected joint torques. In
Newtons and Newtons/rad.
Return Value
A force twist (pose)
integer to binary list(x)
Returns the binary representation of x
Returns a list of bools as the binary representation of the signed integer
value x.
Parameters
x: The integer value to be converted to a binary list.
Return Value
A list of 32 bools, where False represents a zero and True
represents a one. The bool at index 0 is the least significant bit.
interpolate pose(p from, p to, alpha)
Linear interpolation of tool position and orientation.
When alhpa is 0, returns p from. When alpha is 1, returns p to. As alpha
goes from 0 to 1, returns a pose going in a straigt line (and geodaetic
orientation change) from p from to p to. If alpha is less than 0, returns a
point before p from on the line. If alpha is greater than 1, returns a pose
after p to on the line.
Parameters
p from: tool pose (pose)
p to:
tool pose (pose)
alpha:
Floating point number
Return Value
interpolated pose (pose)
23
URScript
Functions
Module urmath
log(b, f )
Returns the logarithm of f to the base b
Returns the logarithm of f to the base b. If b or f are negative, or if b i 1 an
runtime error is raised.
Parameters
b: floating point value
Return Value
the logarithm of f to the base of b.
norm(a)
Returns the norm of the argument
The argument can be one of three diffrent types:
Pose: In this case the euclidian norm of the pose is returned.
Float: In this case fabs(a) is returned.
Int: In this case abs(a) is returned.
Parameters
a: Pose, float or int
Return Value
norm of a
point dist(p from, p to)
Point distance
Parameters
p to:
tool pose (pose)
Return Value
Distance between the two tool positions (without considering
rotations)
24
URScript
Functions
Module urmath
pose add(p 1, p 2)
Pose addition
Both arguments contain three position parameters (x, y, z) jointly called P,
and three rotation parameters (R x, R y, R z) jointly called R. This function
calculates the result x 3 as the addition of the given poses as follows:
p 3.P = p 1.P + p 2.P
p 3.R = p 1.R * p 2.R
Parameters
p 1: tool pose 1(pose)
p 2: tool pose 2 (pose)
Return Value
Sum of position parts and product of rotation parts (pose)
pose dist(p from, p to)
Pose distance
Parameters
p to:
tool pose (pose)
Return Value
distance
pose inv(p from)
Get the invers of a pose
Parameters
p from: tool pose (spatial vector)
Return Value
inverse tool pose transformation (spatial vector)
pose sub(p to, p from)
Pose subtraction
Parameters
p to:
tool pose (spatial vector)
p from: tool pose (spatial vector)

Return Value
tool pose transformation (spatial vector)
25
URScript
Functions
Module urmath
pose trans(p from, p from to)

Pose transformation
The first argument, p from, is used to transform the second argument,
p from to, and the result is then returned. This means that the result is the
resulting pose, when starting at the coordinate system of p from, and
then in that coordinate system moving p from to.
This function can be seen in two different views. Either the function
transforms, that is translates and rotates, p from to by the parameters of
p from. Or the function is used to get the resulting pose, when first making
a move of p from and then from there, a move of p from to.
If the poses were regarded as transformation matrices, it would look like:
T world->to = T world->from * T from->to
T x->to = T x->from * T from->to
Parameters
p from:
starting pose (spatial vector)
p from to: pose change relative to starting pose (spatial

vector)
Return Value
resulting pose (spatial vector)
pow(base, exponent)
Returns base raised to the power of exponent
Returns the result of raising base to the power of exponent. If base is
negative and exponent is not an integral value, or if base is zero and
exponent is negative, a runtime error is raised.
Parameters
base:
floating point value
exponent: floating point value

Return Value
base raised to the power of exponent
random()
Random Number
Return Value
peseudo-random number between 0 and 1 (float)
26
URScript
Variables
Module urmath
sin(f )
Returns the sine of f
Returns the sine of an angle of f radians.
Parameters
Return Value
the sine of f.
sqrt(f )
Returns the square root of f
Returns the square root of f. If f is negative, an runtime error is raised.
Parameters
Return Value
the square root of f.
tan(f )
Returns the tangent of f
Returns the tangent of an angle of f radians.
Parameters
Return Value
the tangent of f.
4.2
Variables
Name
package
Description
Value: None
27
URScript
Module interfaces
5
5.1
Module interfaces
Functions
get analog in(n)
Get analog input level
Parameters
n: The number (id) of the input. (int) @return float, The signal
level [0,1]
get analog out(n)
Get analog output level
Parameters
n: The number (id) of the input. (int)
Return Value
float, The signal level [0;1]
get digital in(n)
Get digital input signal level
Parameters
Return Value
boolean, The signal level.
get digital out(n)
Get digital output signal level
Parameters
n: The number (id) of the output. (int)
Return Value
boolean, The signal level.
28
URScript
Functions
Module interfaces
get euromap input(port number)

Reads the current value of a specific Euromap67 input signal. See
http://support.universal-robots.com/Manuals/Euromap67 for signal
specifications.
>>> var = get euromap input(3)
Parameters
port number: An integer specifying one of the available
Euromap67 input signals.
Return Value
A boolean, either True or False
get euromap output(port number)
Reads the current value of a specific Euromap67 output signal. This
means the value that is sent from the robot to the injection moulding
machine. See http://support.universal-robots.com/Manuals/Euromap67
for signal specifications.
>>> var = get euromap output(3)
Parameters
port number: An integer specifying one of the available
Euromap67 output signals.
Return Value
A boolean, either True or False
get flag(n)
Flags behave like internal digital outputs. The keep information between
program runs.
Parameters
n: The number (id) of the flag [0;32]. (int)
Return Value
Boolean, The stored bit.
29
URScript
Functions
Module interfaces
modbus add signal(IP, slave number, signal address, signal type,

signal name)
Adds a new modbus signal for the controller to supervise. Expects no
response.
>>> modbus add signal("172.140.17.11", 255, 5, 1, "output1")
Parameters
IP:
slave number:
A string specifying the IP address of the

modbus unit to which the modbus signal is
connected.
An integer normally not used and set to
255, but is a free choice between 0 and
255.
signal address: An integer specifying the address of the

either the coil or the register that this new
signal should reflect. Consult the
configuration of the modbus unit for this
information.
signal type:
An integer specifying the type of signal to

add. 0 = digital input, 1 = digital output, 2 =
register input and 3 = register output.
signal name:
A string uniquely identifying the signal. If a

string is supplied which is equal to an
already added signal, the new signal will
replace the old one.
modbus delete signal(signal name)

Deletes the signal identified by the supplied signal name.
>>> modbus delete signal("output1")
Parameters
signal name: A string equal to the name of the signal that
should be deleted.
30
URScript
Functions
Module interfaces
modbus get signal status(signal name, is secondary program)

Reads the current value of a specific signal.
>>> modbus get signal status("output1",False)
Parameters
signal name:
A string equal to the name of the

signal for which the value should be
gotten.
is secondary program: A boolean for interal use only. Must

be set to False.
Return Value
An integer. For digital signals: 1 for True, 0 for False. For register
signals: The register value expressed as an unsigned integer.
For all signals: -1 for inactive signal, check then the signal
name, addresses and connections.
modbus send custom command(IP, slave number, function code, data)
Sends a command specified by the user to the modbus unit located on
the specified IP address. Cannot be used to request data, since the
response will not be received. The user is responsible for supplying data
which is meaningful to the supplied function code. The builtin function
takes care of constructing the modbus frame, so the user should not be
concerned with the length of the command.
>>> modbus send custom command("172.140.17.11",103,6,[17,32,2,88])
The above example sets the watchdog timeout on a Beckhoff BK9050 to

600 ms. That is done using the modbus function code 6 (preset single
register) and then supplying the register address in the first two bytes of
the data array ([17,32] = [0x1120]) and the desired register content in the
last two bytes ([2,88] = [0x0258] = dec 600).
Parameters
IP:
slave number:
A string specifying the IP address locating

the modbus unit to which the custom
command should be send.
An integer specifying the slave number to
use for the custom command.
function code: An integer specifying the function code for

the custom command.
data:
An array of integers in which each entry

must be a valid byte (0-255) value.
31
URScript
Functions
Module interfaces
modbus set output register(signal name, register value,

is secondary program)
Sets the output register signal identified by the given name to the given
value.
>>> modbus set output register("output1",300,False)
Parameters
signal name:
register value:
A string identifying an output

register signal that in advance has
been added.
An integer which must be a valid
word (0-65535) value.

be set to False.
modbus set output signal(signal name, digital value,
is secondary program)
Sets the output digital signal identified by the given name to the given
value.
>>> modbus set output signal("output2",True,False)
Parameters
signal name:
digital value:
A string identifying an output digital

signal that in advance has been
added.
A boolean to which value the
signal will be set.

be set to False.
modbus set runstate dependent choice(signal name, runstate choice)
Sets whether an output signal must preserve its state from a program, or it
must be set either high or low when a program is not running.
>>> set runstate dependent choice("output2",1)
Parameters
signal name:
A string identifying an output digital signal

that in advance has been added.
runstate choice: An integer: 0 = preserve program state, 1

= set low when a program is not running, 2
= set high when a program is not running.
32
URScript
Functions
Module interfaces
modbus set signal update frequency(signal name, update frequency)

Sets the frequency with which the robot will send requests to the Modbus
controller to either read or write the signal value.
>>> modbus set signal update frequency("output2",20)
Parameters
signal name:
A string identifying an output digital

signal that in advance has been added.
update frequency: An integer in the range 1-125 specifying

the update frequency in Hz.
read port bit(address)
Reads one of the ports, which can also be accessed by Modbus clients
>>> boolval = read port bit(3)
Parameters
address: Address of the port (See portmap on Support site,
page UsingModbusServer )
Return Value
The value held by the port (True, False)
read port register(address)
Reads one of the ports, which can also be accessed by Modbus clients
>>> intval = read port register(3)
Parameters
Return Value
The signed integer value held by the port (-32768 : 32767)
set analog inputrange(port, range)
Set range of analog inputs
Port 0 and 1 is in the controller box, 2 and 3 is in the tool connector For the
ports in the tool connector, range code 2 is current input.
Parameters
port:
analog input port number, 0,1 = controller, 2,3 = tool
range: analog input range. 0: 0-5V, 1: -5-5V, 2: 0-10V, 3:

-10-10V
33
URScript
Functions
Module interfaces
set analog out(n, f )

Set analog output level
Parameters
f: The signal level [0;1] (float)
set analog outputdomain(port, domain)
Set domain of analog outputs
Parameters
port:
analog output port number
domain: analog output domain. 0: 4-20mA, 1: 0-10V

set digital out(n, b)
Set digital output signal level
Parameters
n: The number (id) of the output. (int)
b: The signal level. (boolean)
set euromap output(port number, signal value)
Sets the value of a specific Euromap67 output signal. This means the
value that is sent from the robot to the injection moulding machine. See
http://support.universal-robots.com/Manuals/Euromap67 for signal
specifications.
>>> set euromap output(3,True)
Parameters
port number:
An integer specifying one of the available

Euromap67 output signals.
signal value: A boolean, either True or False
34
URScript
Functions
Module interfaces
set euromap runstate dependent choice(port number, runstate choice)

Sets whether an Euromap67 output signal must preserve its state from a
program, or it must be set either high or low when a program is not
running. See http://support.universal-robots.com/Manuals/Euromap67 for
signal specifications.
>>> set runstate dependent choice(3,0)
Parameters
port number:
An integer specifying a Euromap67

output signal.
runstate choice: An integer: 0 = preserve program state, 1

= set low when a program is not running, 2
= set high when a program is not running.
set flag(n, b)
Flags behave like internal digital outputs. The keep information between
program runs.
Parameters
n: The number (id) of the flag [0;32]. (int)
b: The stored bit. (boolean)
set tool voltage(voltage)
Sets the voltage level for the power supply that delivers power to the
connector plug in the tool flange of the robot. The votage can be 0, 12
or 24 volts.
Parameters
voltage: The voltage (as an integer) at the tool connector
socket close(socket name=socket 0)
Closes ethernet communication
Closes down the socket connection to the server.
>>> socket comm close()
Parameters
socket name: Name of socket (string)
35
URScript
Functions
Module interfaces
socket get var(name, socket name=socket 0)

Reads an integer from the server
Sends the message get <name> through the socket. Expects the
response <name> <int> within 2 seconds.
>>> x pos = socket get var("POS X")
Parameters
name:
Variable name (string)

Return Value
an integer from the server (int)
socket open(address, port, socket name=socket 0)
Open ethernet communication
Attempts to open a socket connection, times out after 2 seconds.
Parameters
address:
port:
Server address (string)

Port number (int)

Return Value
False if failed, True if connection succesfully established
socket read ascii float(number, socket name=socket 0)
Reads a number of ascii float from the TCP/IP connected. A maximum of
30 values can be read in one command.
>>> list of four floats = socket read ascii float(4)
The format of the numbers should be with paranthesis, and seperated by

,. An example list of four numbers could look like ( 1.414 , 3.14159,
1.616, 0.0 ).
The returned list would first have the total numbers read, and then each
number in succession. For example a read ascii float on the example
above would return [4, 1.414, 3.14159, 1.616, 0.0].
A failed read will return the list [0].
Parameters
number:
The number of variables to read (int)

Return Value
A list of numbers read (list of floats, length=number+1)
36
URScript
Functions
Module interfaces
socket read binary integer(number, socket name=socket 0)

Reads a number of ascii float from the TCP/IP connected. Bytes are in
network byte order. A maximum of 16 values can be read in one
command.
>>> list of three ints = socket read binary integer(3)
Returns (for example) [3,100,2000,30000]

Parameters
number:

Return Value
A list of numbers read (list of ints, length=number+1)
socket read byte list(number, socket name=socket 0)
Reads a number of ascii float from the TCP/IP connected. Bytes are in
network byte order. A maximum of 16 values can be read in one
command.
>>> list of three ints = socket read byte list(3)
Returns (for example) [3,100,200,44]

Parameters
number:

Return Value
A list of numbers read (list of ints, length=number+1)
socket read string(socket name=socket 0)
Reads a string from the TCP/IP connected. Bytes are in network byte
order.
>>> string from server = socket read string()
Returns (for example) reply string from the server

Parameters
Return Value
A string variable
37
URScript
Functions
Module interfaces
socket send byte(value, socket name=socket 0)

Sends a byte to the server
Sends the byte <value> through the socket. Expects no response. Can
be used to send special ASCII characters; 10 is newline, 2 is start of text, 3
is end of text.
Parameters
value:
The number to send (byte)

socket send int(value, socket name=socket 0)
Sends an int (int32 t) to the server
Sends the int <value> through the socket. Send in network byte order.
Expects no response.
Parameters
value:
The number to send (int)

socket send line(str, socket name=socket 0)
Sends a string with a newline character to the server - useful for
communicatin with the UR dashboard server
Sends the string <str> through the socket in ASCII coding. Expects no
response.
Parameters
str:
The string to send (ascii)

socket send string(str, socket name=socket 0)
Sends a string to the server
Sends the string <str> through the socket in ASCII coding. Expects no
response.
Parameters
str:
The string to send (ascii)
38
URScript
Variables
Module interfaces
socket set var(name, value, socket name=socket 0)

Sends an integer to the server
Sends the message set <name> <value> through the socket. Expects
no response.
>>> socket set var("POS Y",2200)
Parameters
name:
Variable name (string)

The number to send (int)
value:

write port bit(address, value)
Writes one of the ports, which can also be accessed by Modbus clients
>>> write port bit(3,True)
Parameters
value:
Value to be set in the register (True, False)
write port register(address, value)

Writes one of the ports, which can also be accessed by Modbus clients
>>> write port register(3,100)
Parameters
value:
5.2
Value to be set in the port (0 : 65536) or (-32768 :

32767)
Variables
Name
package
Description
Value: None
39
URScript

The URScript Programming Language

Uploaded by

Copyright:

Available Formats

The URScript Programming Language

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

The URScript Programming Language

Uploaded by

Copyright:

Available Formats

The URScript Programming Language