�
I i�5 � �F � d dl Z dZdZdZd dlZd dlZd dlZ G d� de� Z y)� NzAnthony ZhuangzCopyright 2009-2025z MIT Licensec �F � e Zd ZdZd|d�Zd� Zd}d�Zd~d�Zdd �Zd�d
�Z d�d �Z
g d �g d
�g d �dg d�ddfd�Z d|d�Z d�d�Z
d�d�Zd�d�Zd�d�Zd�d�Zd�d�Zd|d�Zd�d�Zd�d�Zd�d �Zd�d �Zd�d �Zd � Zd�d �Zd�d!�Zd�d"�Z d�d#�Z g d �dfd$�Z d�d%�Z d�d&�Z d�d'�Z!d�d(�Z"d�d)�Z#d�d*�Z$d�d+�Z%d�d,�Z&d�d-�Z'd.� Z(d/� Z)g d0�d1d1fd2�Z*d3� Z+d4� Z,d5� Z-d6� Z.d7� Z/d8� Z0d�d9�Z1d:� Z2d;� Z3d<� Z4d=� Z5d�d>�Z6d?� Z7d�d@�Z8dA� Z9d�dB�Z:d�dC�Z;d�dD�Z<dE� Z=dF� Z>d�dG�Z?e@dH� � ZAdI� ZBdJ� ZCdK� ZDdL� ZEdM� ZFd�dN�ZGd�dO�ZHd�dP�ZIdQ� ZJdR� ZKdS� ZLdT� ZMdU� ZNdV� ZOdW� ZPdX� ZQdY� ZRdZ� ZSd[� ZTd\� ZUd]� ZVd^� ZWd_� ZXd`� ZYda� ZZdb� Z[dc� Z\dd� Z]de� Z^d�df�Z_dg� Z`dh� Zadi� Zbdj� Zcdk� Zddl� Zedm� Zfdn� Zgdo� Zhdp� Zidq� Zjdr� Zkds� Zldt� Zmdu� Zndv� Zodw� Zpdx� Zqdy� Zrdz� Zsd{� Zty)��UrScripta�
Interface to remote access UR script commands.
For more details see the script manual at this site:
http://www.universal-robots.com/download/
Beside the implementation of the script interface, this class also inherits from the
Real Time Client and RTDE interface and thereby also open a connection to these data interfaces.
The Real Time Client in this version is only used to send program and script commands
to the robot, not to read data from the robot, all data reading is done via the RTDE interface.
The constructor takes a UR robot hostname as input, and a RTDE configuration file, and optional a logger object.
Input parameters:
host (string): hostname or IP of UR Robot (RT CLient server)
rtde_conf_filename (string): Path to xml file describing what channels to activate
Example:
rob = URBasic.urScript.UrScript('192.168.56.101', rtde_conf_filename='rtde_configuration.xml')
self.close_rtc()
Fc �| � t j j |||� | _ | j j j � �Et d� t
j d� | j j j � ��Et | j j j � � y)zB
Constructor see class description for more info.
Nz"waiting for everything to be ready� )�URBasic�robotConnector�RobotConnector�
RobotModel�
ActualTCPPose�print�time�sleep)�self�host�
robotModel�hasForceTorques �CD:\MyProgram\GitLab\NOENAD-Universal-Robots-MCP\URBasic\urScript.py�__init__zUrScript.__init__# s� � � &� 4� 4� C� C�J�PT�Vd� e����"�"�-�-�;�;�=�E� �6� 7� �J�J�q�M� �"�"�-�-�;�;�=�E� �d�!�!�,�,�:�:�<�=� c � � | j j j � r�| j j j � s^t j
d� | j j j � r%| j j j � s�^| j j j r t d� �y )Ng����Mb`?z Robot program execution error!!!)r r
� RuntimeState�StopRunningFlagr
r �rtcProgramExecutionError� RuntimeError�r s r �waitRobotIdleOrStopFlagz UrScript.waitRobotIdleOrStopFlag0 s� � ��"�"�-�-�:�:�<�T�EX�EX�Ec�Ec�Es�Es�Eu� �J�J�u� � �"�"�-�-�:�:�<�T�EX�EX�Ec�Ec�Es�Es�Eu� � � � )� )� B� B� � A�B� B� Cr NTc
�� � d}| j d|||||||�� } |j di t � ��}
| j j j |
� |r| j
� yy)a
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 (Can also be a pose)
a: joint acceleration of leading axis [rad/s^2]
v: joint speed of leading axis [rad/s]
t: time [S]
r: blend radius [m]
wait: function return when movement is finished
pose: target pose
z def move_j():
{movestr}
end
�j��movetype�pose�a�v�t�r�wait�qN� ��_move�format�localsr �RealTimeClient� SendProgramr ) r r' r" r# r$ r% r& r! �prg�movestr�
programStrings r �movejzUrScript.movej8 sm � �*�� �*�*�c���Q�!�q�t�WX�*�Y��"��
�
�.�V�X�.�
� ���*�*�6�6�}�E� � � (� (� *�
r c
�� � d}| j d|||||||�� } |j di t � ��}
| j j j |
� |r| j
� yy)ak
Move to position (linear in tool-space)
See movej.
Parameters:
pose: target pose (Can also be a joint position)
a: tool acceleration [m/s^2]
v: tool speed [m/s]
t: time [S]
r: blend radius [m]
wait: function return when movement is finished
q: joint position
z def move_l():
{movestr}
end
�lr Nr( r) ) r r! r" r# r$ r% r& r' r/ r0 r1 s r �movelzUrScript.movelY sm � � �� �*�*�c���Q�!�q�t�WX�*�Y��"��
�
�.�V�X�.�
� ���*�*�6�6�}�E� � � (� (� *�
r c
�� � d}| j d|||d|||�� } |j di t � ��} | j j j | � |r| j
� yy)a>
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:
pose: list of target pose (pose can also be specified as joint
positions, then forward kinematics is used to calculate the corresponding pose)
a: tool acceleration [m/s^2]
v: tool speed [m/s]
r: blend radius [m]
wait: function return when movement is finished
q: list of target joint positions
� def move_p():
{movestr}
end
�pr r Nr( r) )
r r! r" r# r% r& r' r/ r0 r1 s
r �movepzUrScript.movept sm � � �� �*�*�c���Q�!�q�t�WX�*�Y��"��
�
�.�V�X�.�
� ���*�*�6�6�}�E� � � (� (� *�
r c �� � d} | j d|||d|||||��
}
| j di t � ��} | j j j | � |r| j
� yy)a�
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/s^2]
v: tool speed [m/s]
r: blend radius (of target pose) [m]
wait: function return when movement is finished
q_via: list of via joint positions
q_to: list of target joint positions
r7 r8 r )
r r! r" r# r$ r% r& r' �pose_via�q_viaNr( r) ) r r; �pose_tor" r# r% r& r< �q_tor/ r0 r1 s r �moveczUrScript.movec� s{ � �(�� �*�*�c��1��Q�!�RV�Z^�iq�#(� � *�� #��
�
�.�V�X�.�
� ���*�*�6�6�}�E� � � (� (� *�
r c �� � d} d} d}
|�d} |}t j |� }|dk( s|dk( r dj di t � ��}|dk( r8| �d}|
} nd}t j | � } |j | j k7 ryd}t j
|j � dk( r�t
t j
|d � � D ]� }t j || d
� }|j � }|dk( r+t j | | d
� }|j � }d }
t j
|d � d z
|k( rd }| d
j di t � ��z
}�� | dj di t � ��z
}|S t j |d
� }|j � }|dk( r(t j | d
� }|j � }d }
| d
j di t � ��z
}|S )ac
General 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:
movetype: j, l, p, c
pose: list of target pose (pose can also be specified as joint
positions, then forward kinematics is used to calculate the corresponding pose)
a: tool acceleration [m/s^2]
v: tool speed [m/s]
r: blend radius [m]
wait: function return when movement is finished
q: list of target joint positions
r8 � r r4 zt={t},�cF� r � z{prefix_via}{pose_via_x},r zP move{movetype}({pose_via_val} {prefix}{posex}, a={a}, v={v}, {t_val} r={r})
z stopl({a})
r( ) �np�arrayr+ r, �shape�size�range�round�tolist)r r r! r" r# r$ r% r& r' r; r< �prefix�t_val� pose_via_val�tval�
prefix_viar0 �idx�posex�
pose_via_xs r r* zUrScript._move� s� � �" ����� � �<��F��D��x�x��~�� �s�?�h�#�o�"�8�?�?�.�V�X�.�D� �s�?�� � �
� �� �
��x�x��)�H� �
�
�h�n�n�,� ���
�7�7�4�:�:� �!� #� �R�W�W�T�1� -�.������c��A�.�� � � ����s�?�!#���(�3�-��!;�J�!+�!2�!2�!4�J�#>�L��G�G�D�!�$�q�(�S�0��A��u�n�u�u� � �h� � �� /�
�0�)�0�0�<�6�8�<� <�G� �� �H�H�T�1�%�E��L�L�N�E��3�� �X�X�h�� 2�
� '� .� .� 0�
� :� � �q�j�q�q� ��(� �
�G� �r )� rT rT rT rT rT )r r r r r r rC )rC rC g �?r r r �< c � � d} |j di t � ��} | j j j | � |r| j � yy)aK
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.
f_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 f_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.
z�def ur_force_mode():
while True:
force_mode(p{task_frame}, {selection_vector}, {wrench}, {f_type}, {limits})
sync()
end
end
Nr( �r+ r, r r- r. r )
r �
task_frame�selection_vector�wrench�f_type�limitsr& �timeoutr/ r1 s
r �
force_modezUrScript.force_mode� sO � �H�� #��
�
�.�V�X�.�
� ���*�*�6�6�}�E� � � (� (� *�
r c �� � d} |j di t � ��}| j j j |� |r| j � t
j d� y)z|
Resets the robot mode from force mode to normal operation.
This is also done when a program stops.
zend_force_mode()
皙�����?Nr( �r+ r, r r- �Sendr r
r �r r& r/ r1 s r �end_force_modezUrScript.end_force_mode& sS � �
#��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *� �
�
�4�r c � � d} |j di t � ��}| j j j |� |r| j � yy)a7
Servo Circular
Servo to position (circular in tool-space). Accelerates to and moves with constant tool speed v.
Parameters:
pose: target pose
a: tool acceleration [m/s^2]
v: tool speed [m/s]
r: blend radius (of target pose) [m]
z servoc(p{pose}, {a}, {v}, {r})
Nr( �r+ r, r r- rb r )r r! r" r# r% r& r/ r1 s r �servoczUrScript.servoc3 sL � � 1��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *�
r c � � d} |j di t � ��}| j j j |� |r| j � yy)a#
Servo to position (linear in joint-space)
Servo function used for online control of the robot. The lookahead time
and the gain can be used to smoothen or sharpen the trajectory.
Note: A high gain or a short lookahead time may cause instability.
Prefered use is to call this function with a new setpoint (q) in each time
step (thus the default t=0.008)
Parameters:
q: joint positions [rad]
t: time where the command is controlling
the robot. The function is blocking for time t [S]
lookahead_time: time [S], range [0.03,0.2] smoothens the trajectory with this lookahead time
gain: proportional gain for following target position, range [100,2000]
z5servoj({q}, 0.5, 0.5, {t}, {lookahead_time}, {gain})
Nr( rf )r r' r$ �lookahead_time�gainr& r/ r1 s r �servojzUrScript.servojF sM � � G��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *�
r c � � d} |j di t � ��}| j j j |� |r| j � yy)a
Joint speed
Accelerate linearly in joint space and continue with constant joint
speed. The time t is optional; if provided the function will return after
time t, regardless of the target speed has been reached. If the time t is
not provided, the function will return when the target speed is reached.
Parameters:
qd: joint speeds [rad/s]
a: joint acceleration [rad/s^2] (of leading axis)
t: time [s] before the function returns (optional)
zspeedj({qd}, {a}, {t})
Nr( rf )r �qdr" r$ r& r/ r1 s r �speedjzUrScript.speedj\ sL � � )��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *�
r c � � d} |j di t � ��}| j j j |� |r| j � yy)z�
Stop (linear in joint space)
Decellerate joint speeds to zero
Parameters
a: joint acceleration [rad/s^2] (of leading axis)
z stopj({a})
Nr( rf �r r" r& r/ r1 s r �stopjzUrScript.stopjo �L � � ��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *�
r c � � |�|}d} |j di t � ��}| j j j |� |r| j � yy)av
Tool speed
Accelerate linearly in Cartesian space and continue with constant tool
speed. The time t is optional; if provided the function will return after
time t, regardless of the target speed has been reached. If the time t is
not provided, the function will return when the target speed is reached.
Parameters:
xd: tool speed [m/s] (spatial vector)
a: tool position acceleration [m/s^2]
t: time [s] before function returns (optional)
aRot: tool acceleration [rad/s^2] (optional), if not defined a, position acceleration, is used
NzUdef ur_speedl():
while(True):
speedl({xd}, {a}, {t}, {aRot})
end
end
r( rW )r �xdr" r$ �aRotr& r/ r1 s r �speedlzUrScript.speedl} s\ � � �<��D��� #��
�
�.�V�X�.�
� ���*�*�6�6�}�E�
� � (� (� *�
r c � � d} |j di t � ��}| j j j |� |r| j � yy)z�
Stop (linear in tool space)
Decellerate tool speed to zero
Parameters:
a: tool accleration [m/s^2]
z stopl({a})
Nr( rf rp s r �stoplzUrScript.stopl� rr r c � � d} |j di t � ��}| j j j |� |r| j � yy)z�
Set robot in freedrive mode. In this mode the robot can be moved around by hand in the
same way as by pressing the "freedrive" button.
The robot will not be able to follow a trajectory (eg. a movej) in this mode.
zbdef ur_freedrive_mode():
while(True):
freedrive_mode()
sleep(600)
end
end
Nr( rW rc s r �freedrive_modezUrScript.freedrive_mode� sN � � �� #��
�
�.�V�X�.�
� ���*�*�6�6�}�E� � � (� (� *�
r c �� � d} |j di t � ��}| j j j |� |r| j � t
j d� y)�V
Set robot back in normal position control mode after freedrive mode.
zend_freedrive_mode()
r` Nr( ra rc s r �end_freedrive_modezUrScript.end_freedrive_mode� sS � � '��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *� �
�
�4�r c � � d} |j di t � ��}| j j j |� |r| j � yy)z�
Set robot in freedrive mode. In this mode the robot can be moved
around by hand in the same way as by pressing the "freedrive" button.
The robot will not be able to follow a trajectory (eg. a movej) in this mode.
zFdef ur_teach_mode():
while True:
teach_mode()
end
end
Nr( rW rc s r �
teach_modezUrScript.teach_mode� sN � � �� #��
�
�.�V�X�.�
� ���*�*�6�6�}�E� � � (� (� *�
r c �� � d} |j di t � ��}| j j j |� |r| j � t
j d� y)r| zend_teach_mode()
r` Nr( ra rc s r �end_teach_modezUrScript.end_teach_mode� sS � � #��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *� �
�
�4�r c � � d} |j di t � ��}| j j j |� |r| j � yy)aF
Tells the robot controller to treat digital inputs number A and B as pulses
for a conveyor encoder. Only digital input 0, 1, 2 or 3 can be used.
>>> conveyor pulse decode(1,0,1)
This example shows how to set up quadrature pulse decoding with
input A = digital in[0] and input B = digital in[1]
>>> conveyor pulse decode(2,3)
This example shows how to set up rising and falling edge pulse
decoding with input A = digital in[3]. Note that you do not have to set
parameter B (as it is not used anyway).
Parameters:
in_type: An integer determining how to treat the inputs on A
and B
0 is no encoder, pulse decoding is disabled.
1 is quadrature encoder, input A and B must be
square waves with 90 degree offset. Direction of the
conveyor can be determined.
2 is rising and falling edge on single input (A).
3 is rising edge on single input (A).
4 is falling edge on single input (A).
The controller can decode inputs at up to 40kHz
A: Encoder input A, values of 0-3 are the digital inputs 0-3.
B: Encoder input B, values of 0-3 are the digital inputs 0-3.
z+conveyor_pulse_decode({in_type}, {A}, {B})
Nr( rf )r �in_type�A�Br& r/ r1 s r �conveyor_pulse_decodez UrScript.conveyor_pulse_decode� sL � �> =��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *�
r c � � d} |j di t � ��}| j j j |� |r| j � yy)a�
Tells the robot controller the tick count of the encoder. This function is
useful for absolute encoders, use conveyor pulse decode() for setting
up an incremental encoder. For circular conveyors, the value must be
between 0 and the number of ticks per revolution.
Parameters:
tick_count: Tick count of the conveyor (Integer)
absolute_encoder_resolution: Resolution of the encoder, needed to
handle wrapping nicely.
(Integer)
0 is a 32 bit signed encoder, range [-2147483648 ;2147483647] (default)
1 is a 8 bit unsigned encoder, range [0 ; 255]
2 is a 16 bit unsigned encoder, range [0 ; 65535]
3 is a 24 bit unsigned encoder, range [0 ; 16777215]
4 is a 32 bit unsigned encoder, range [0 ; 4294967295]
zEset_conveyor_tick_count({tick_count}, {absolute_encoder_resolution})
Nr( rf )r �
tick_count�absolute_encoder_resolutionr& r/ r1 s r �set_conveyor_tick_countz UrScript.set_conveyor_tick_count
sM � �" W��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *�
r c �� � d} |j di t � ��}| j j j |� | j � | j j j d S )z�
Tells the tick count of the encoder, note that the controller interpolates tick counts to get
more accurate movements with low resolution encoders
Return Value:
The conveyor encoder tick count
zddef ur_get_conveyor_tick_count():
write_output_float_register(0, get_conveyor_tick_count())
end
r r( )r+ r, r r- r. r r
�outputDoubleRegister)r r/ r1 s r �get_conveyor_tick_countz UrScript.get_conveyor_tick_count% sc � ��� #��
�
�.�V�X�.�
� ���*�*�6�6�}�E� �$�$�&��"�"�-�-�B�B�1�E�Er c � � d} |j di t � ��}| j j j |� |r| j � yy)aG
Stop tracking the conveyor, started by track conveyor linear() or
track conveyor circular(), and decellerate tool speed to zero.
Parameters:
a: tool accleration [m/s^2] (optional)
aRot: tool acceleration [rad/s^2] (optional), if not defined a, position acceleration, is used
z$stop_conveyor_tracking({a}, {aRot})
Nr( rf )r r" ru r& r/ r1 s r �stop_conveyor_trackingz UrScript.stop_conveyor_tracking8 sL � � 6��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *�
r c � � d} |j di t � ��}| j j j |� |r| j � yy)at
Makes robot movement (movej() etc.) track a circular conveyor.
>>> track conveyor circular(p[0.5,0.5,0,0,0,0],500.0, false)
The example code makes the robot track a circular conveyor with
center in p[0.5,0.5,0,0,0,0] of the robot base coordinate system, where
500 ticks on the encoder corresponds to one revolution of the circular
conveyor around the center.
Parameters:
center: Pose vector that determines the center the conveyor in the base
coordinate system of the robot.
ticks_per_revolution: How many tichs the encoder sees when the conveyor moves one revolution.
rotate tool: Should the tool rotate with the coneyor or stay in the orientation
specified by the trajectory (movel() etc.).
zItrack_conveyor_circular({center}, {ticks_per_revolution}, {rotate_tool})
Nr( rf )r �center�ticks_per_revolution� rotate_toolr& r/ r1 s r �track_conveyor_circularz UrScript.track_conveyor_circularH sM � �" [��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *�
r c � � d} |j di t � ��}| j j j |� |r| j � yy)a`
Makes robot movement (movej() etc.) track a linear conveyor.
>>> track conveyor linear(p[1,0,0,0,0,0],1000.0)
The example code makes the robot track a conveyor in the x-axis of
the robot base coordinate system, where 1000 ticks on the encoder
corresponds to 1m along the x-axis.
Parameters:
direction: Pose vector that determines the direction of the conveyor in the base
coordinate system of the robot
ticks per meter: How many tichs the encoder sees when the conveyor moves one meter
z6track_conveyor_linear({direction}, {ticks_per_meter})
Nr( rf )r � direction�ticks_per_meterr& r/ r1 s r �track_conveyor_linearz UrScript.track_conveyor_lineara sM � � H��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *�
r c � � d} |j di t � ��}| j j j |� |r| j � yy)a�
Write a message to the log when the robot position deviates from the target position.
Parameters:
enabled: enable or disable position deviation log messages (Boolean)
threshold: (optional) should be a ratio in the range ]0;1], where 0 is no position deviation and 1 is the
position deviation that causes a protective stop (Float).
z3position_deviation_warning({enabled}, {threshold})
Nr( rf )r �enabled� thresholdr& r/ r1 s r �position_deviation_warningz#UrScript.position_deviation_warningw sM � � E��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *�
r c � � d} |j di t � ��}| j j j |� |r| j � yy)a�
Reset the revolution counter, if no offset is specified. This is applied on
joints which safety limits are set to "Unlimited" and are only applied
when new safety settings are applied with limitted joint angles.
>>> reset revolution counter()
Parameters:
qNear: Optional parameter, reset the revolution counter to one close to the given qNear joint vector.
If not defined, the joint's actual number of revolutions are used.
z reset_revolution_counter(qNear)
Nr( rf )r �qNearr& r/ r1 s r �reset_revolution_counterz!UrScript.reset_revolution_counter� sL � � 2��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *�
r c � � d} |j di t � ��}| j j j |� |r| j � yy)zf
Set joint positions of simulated robot
Parameters
q: joint positions
z
set_pos({q})
Nr( rf )r r' r& r/ r1 s r �set_poszUrScript.set_pos� sL � � ��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *�
r c � � d} |j di t � ��}| j j j |� |r| j � yy)a0
Sets the damping parameter in force mode.
Parameters
damping: Between 0 and 1, default value is 0.
Value of 1 is full damping, so the robot will decelerate quickly if no force is present. A value of 0 is
no damping, here the robot will maintain the speed
z"force_mode_set_damping({damping})
Nr( rf )r �dampingr& r/ r1 s r �force_mode_set_dampingz UrScript.force_mode_set_damping� sL � � 4��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *�
r c � � d} |j di t � ��}| j j j |� |r| j � yy)z�
Scales the gain in force mode
Parameters
scaling: Between 0 and 2, default value is 1.
A value larger than 1 can make force mode unstable, e.g. in case of collisions or pushing against
hard surfaces.
z'force_mode_set_gain_scaling({scaling})
Nr( rf )r �scalingr& r/ r1 s r �force_mode_set_gain_scalingz$UrScript.force_mode_set_gain_scaling� sL � � 9��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *�
r c � � d} |j di t � ��}| j j j |� |r| j � yy)a�
Zeroes the TCP force/torque measurement from the builtin force/torque sensor by subtracting the
current measurement from the subsequent.
:param wait: a boolean (True or False). If equal to True the script would wait for the robot to respond.
:return:
Daniel: it is advised to use it before using force_mode to tear sensor and obtain more accurate sensor measurements
zzero_ftsensor()
Nr( rf rc s r �
zero_ftsensorzUrScript.zero_ftsensor� sL � � "��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *�
r c � � t d� �)a
Returns the force exerted at the TCP
Return the current externally exerted force at the TCP. The force is the
norm of Fx, Fy, and Fz calculated using get tcp force().
Return Value
The force in Newtons (float)
� Function Not yet implemented��NotImplementedError�r r& s r �forcezUrScript.force� � � � "�"@�A�Ar c �n � |r| j � | j j j � S )a�
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]
)�syncr r
�ActualQr� s r �get_actual_joint_positionsz#UrScript.get_actual_joint_positions� s+ � �
� �I�I�K��"�"�-�-�5�5�7�7r c �f � |r| j � | j j j S )a�
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, Shoulder, Elbow, Wrist1, Wrist2, Wrist3]
)r� r r
�ActualQDr� s r �get_actual_joint_speedsz UrScript.get_actual_joint_speeds s( � �
� �I�I�K��"�"�-�-�6�6�6r c �n � |r| j � | j j j � S )ac
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])
)r� r r
r r� s r �get_actual_tcp_posez UrScript.get_actual_tcp_pose s+ � �
� �I�I�K��"�"�-�-�;�;�=�=r c �n � |r| j � | j j j � S )a�
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])
)r� r r
�ActualTCPSpeedr� s r �get_actual_tcp_speedz UrScript.get_actual_tcp_speed+ s+ � � � �I�I�K��"�"�-�-�<�<�>�>r c � � t d� �)a
Returns the current measured tool flange pose
Returns the 6d pose representing the tool flange position and
orientation specified in the base frame, without the Tool Center Point
offset. The calculation of this pose is based on the actual robot
encoder readings.
Return Value:
The current actual tool flange vector : ([X, Y, Z, Rx, Ry, Rz])
Note: See get actual tcp pose for the actual 6d pose including TCP offset.
r� r� r s r �get_actual_tool_flange_posez$UrScript.get_actual_tool_flange_pose: � � � "�"@�A�Ar c � � t d� �)z�
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)
r� r� r s r �get_controller_tempz UrScript.get_controller_tempJ r� r )g��������g333333��g�������g�������g�������?rT g-C ��6?c � � t d� �)a�
Inverse kinematic transformation (tool space -> joint space).
Solution closest to current joint positions is returned, unless qnear defines one.
Parameters:
x: tool pose (spatial vector)
qnear: joint positions to select solution.
Optional.
maxPositionError: Define the max allowed position error.
Optional.
maxOrientationError: Define the max allowed orientation error.
Optional.
Return Value:
joint positions
r� r� )r �x�qnear�maxPositionError�maxOrientationErrors r �get_inverse_kinzUrScript.get_inverse_kinU � � �$ "�"@�A�Ar c � � t d� �)ah
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)
r� r� )r r s r �get_joint_tempzUrScript.get_joint_tempi � � � "�"@�A�Ar c � � t d� �)a
Returns the torques of all joints
The torque on the joints, corrected by the torque
robot itself (gravity, friction, etc.), returned as
Return Value:
The joint torque vector in ; ([float])
r� r� r s r �get_joint_torqueszUrScript.get_joint_torquesx � � � "�"@�A�Ar c � � t d� �)a�
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,
Shoulder, Elbow, Wrist1, Wrist2, Wrist3]
r� r� r s r �get_target_joint_positionsz#UrScript.get_target_joint_positions� r� r c � � t d� �)a�
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, Shoulder, Elbow, Wrist1, Wrist2, Wrist3]
r� r� r s r �get_target_joint_speedsz UrScript.get_target_joint_speeds� r� r c � � t d� �)ac
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])
r� r� r s r �get_target_tcp_posez UrScript.get_target_tcp_pose� � � � "�"@�A�Ar c � � t d� �)a�
Returns the current target TCP speed
The desired speed of the TCP returned 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)
r� r� r s r �get_target_tcp_speedz UrScript.get_target_tcp_speed� � � � "�"@�A�Ar c �n � |r| j � | j j j � S )aW
Returns the wrench (Force/Torque vector) at the TCP
The external wrench is computed based on the error between the joint
torques required to stay on the trajectory and the expected joint
torques. The function returns "p[Fx (N), Fy(N), Fz(N), TRx (Nm), TRy (Nm),
TRz (Nm)]". where Fx, Fy, and Fz are the forces in the axes of the robot
base coordinate system measured in Newtons, and TRx, TRy, and TRz
are the torques around these axes measured in Newton times Meters.
Return Value:
the wrench (pose)
)r� r r
�ActualTCPForcer� s r �
get_tcp_forcezUrScript.get_tcp_force� s+ � �
� �I�I�K��"�"�-�-�<�<�>�>r c � � t d� �)ax
Returns the current reading of the tool accelerometer as a
three-dimensional vector.
The accelerometer axes are aligned with the tool coordinates, and
pointing an axis upwards results in a positive reading.
Return Value:
X, Y, and Z composant of the measured acceleration in
SI-units (m/s^2).
r� r� r s r � get_tool_accelerometer_readingz'UrScript.get_tool_accelerometer_reading� r� r c � � t d� �)z�
Returns the tool current
The tool current consumption measured in ampere.
Return Value:
The tool current in ampere.
r� r� r s r �get_tool_currentzUrScript.get_tool_current� r� r c � � t d� �)a~
Checks if robot is fully at rest.
True when the robot is fully at rest, and ready to accept higher external
forces and torques, such as from industrial screwdrivers. It is useful in
combination with the GUI's wait node, before starting the screwdriver
or other actuators influencing the position of the robot.
Note: This function will always return false in modes other than the
standard position mode, e.g. false in force and teach mode.
Return Value:
True when the robot is fully at rest. Returns False otherwise
(bool)
r� r� r s r � is_steadyzUrScript.is_steady� � � � "�"@�A�Ar c � � t d� �)a�
Checks if the given pose is reachable and within the current safety
limits of the robot.
This check considers joint limits (if the target pose is specified as joint
positions), safety planes limits, TCP orientation deviation limits and
range of the robot. If a solution is found when applying the inverse
kinematics to the given target TCP pose, this pose is considered
reachable.
Parameters:
pose: Target pose (which can also be specified as joint positions)
Return Value:
True if within limits, false otherwise (bool)
r� r� )r r! s r �is_within_safety_limitsz UrScript.is_within_safety_limits� � � �" "�"@�A�Ar c � � t d� �)z�
Display popup on GUI
Display message in popup window on GUI.
Parameters:
s: message string
title: title string
warning: warning message?
error: error message?
r� r� )r �s�title�warning�errors r �popupzUrScript.popup
r� r c � � t d� �)zM
Shutdown the robot, and power off the robot and controller.
r� r� r s r � powerdownzUrScript.powerdown s � � "�"@�A�Ar c � � d} |j di t � ��}| j j j |� |r| j � yy)ax
Set the direction of the acceleration experienced by the robot. When
the robot mounting is fixed, this corresponds to an accleration of g
away from the earth's centre.
>>> set gravity([0, 9.82*sin(theta), 9.82*cos(theta)])
will set the acceleration for a robot that is rotated "theta" radians
around the x-axis of the robot base coordinate system
Parameters:
d: 3D vector, describing the direction of the gravity, relative to the base of the robot.
Exampel:
set_gravity([0,0,9.82]) #Robot mounted at flore
zset_gravity({d})
Nr( rf )r �dr& r/ r1 s r � set_gravityzUrScript.set_gravity! sL � �$ #��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *�
r c � � t d� �)a�
Set payload mass and center of gravity
Alternatively one could use set payload mass and set payload cog.
Sets the mass and center of gravity (abbr. CoG) of the payload.
This function must be called, when the payload weight or weight
distribution changes - 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.
r� r� )r �m�CoGs r � set_payloadzUrScript.set_payload; s � �0 "�"@�A�Ar c � � d} |j di t � ��}| j j j |� |r| j � yy)a�
Set center of gravity
See also set payload.
Sets center of gravity (abbr. CoG) of the payload.
This function must be called, when the weight distribution changes - i.e
when the robot picks up or puts down a heavy workpiece.
The CoG is specified as a vector, [CoGx, CoGy, CoGz], displacement,
from the toolmount.
Parameters:
CoG: Center of Gravity: [CoGx, CoGy, CoGz] in meters.
zset_payload_cog({CoG})
Nr( rf )r r� r& r/ r1 s r �set_payload_cogzUrScript.set_payload_cogU sL � �$ )��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *�
r c � � d} |j di t � ��}| j j j |� |r| j � yy)aG
Set payload mass
See also set payload.
Sets the mass of the payload.
This function must be called, when the payload weight changes - i.e
when the robot picks up or puts down a heavy workpiece.
Parameters:
m: mass in kilograms
zset_payload_mass({m})
Nr( rf )r r� r& r/ r1 s r �set_payload_masszUrScript.set_payload_masso sL � � (��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *�
r c �@ � t |� j t j k( r|j � }d} |j
di t
� ��}| j j j |� |r| j � t j d� y)z�
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.
zset_tcp(p{pose})
r` Nr( )
�type�
__module__rE �__name__rK r+ r, r r- rb r r
r )r r! r& r/ r1 s r �set_tcpzUrScript.set_tcp� st � � ��:� � �B�K�K� /��;�;�=�D�"��"��
�
�.�V�X�.�
� ���*�*�/�/�
�>� � � (� (� *� �
�
�4�r c �. � t j |� y)z^
Sleep for an amount of time
Parameters:
t: time [s]
N)r
r )r r$ s r r zUrScript.sleep� s � �
�
�
�1�
r c � � | j j j � }| j j j � |k( r>t j d� | j j j � |k( r�=yy)zi
Uses up the remaining "physical" time a thread has in the current
frame/sample.
g����MbP?N)r r
�RobotTimestampr
r )r �initialRobotTimes r r� z
UrScript.sync� si � �
�.�.�9�9�H�H�J���"�"�-�-�<�<�>�BR�R� �J�J�u� � �"�"�-�-�<�<�>�BR�Rr c � � t d� �)ah
Send text message to log
Send message with s1 and s2 concatenated to be shown on the GUI
log-tab
Parameters
s1: message string, variables of other types (int, bool poses
etc.) can also be sent
s2: message string, variables of other types (int, bool poses
etc.) can also be sent
r� r� )r �s1�s2s r �textmsgzUrScript.textmsg� r� r c �� � t j j | � }t j j |� }t j ||� }t j j |� }|S )a
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)
)r � kinematic�
Pose2Tran_MatrE �matmul�
Tran_Mat2Pose)�p_1�p_2�Trans_1�Trans_2�Trans_3�p_3s r �pose_addzUrScript.pose_add� s[ � �& �#�#�1�1�#�6���#�#�1�1�#�6���)�)�G�W�-��� � �-�-�g�6���
r c �L � | j j j |� S )a
Get configurable digital input signal level
See also get standard digital in and get tool digital in.
Parameters:
n: The number (id) of the input, integer: [0:7]
Return Value:
boolean, The signal level.
)r r
�ConfigurableInputBits�r �ns r �get_configurable_digital_inz$UrScript.get_configurable_digital_in� s! � � �"�"�-�-�C�C�A�F�Fr c �L � | j j j |� S )a#
Get configurable digital output signal level
See also get standard digital out and get tool digital out.
Parameters:
n: The number (id) of the output, integer: [0:7]
Return Value:
boolean, The signal level.
)r r
�ConfigurableOutputBitsr s r � get_configurable_digital_outz%UrScript.get_configurable_digital_out� s! � � �"�"�-�-�D�D�Q�G�Gr c � � t d� �)a�
Reads the current value of a specific Euromap67 input signal. See
http://universal-robots.com/support 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
r� r� �r � port_numbers r �get_euromap_inputzUrScript.get_euromap_input� r� r c � � t d� �)a�
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://universal-robots.com/support 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
r� r� r s r �get_euromap_outputzUrScript.get_euromap_output r� r c � � t d� �)z�
Flags behave like internal digital outputs. The keep information
between program runs.
Parameters
n: The number (id) of the flag, intereger: [0:32]
Return Value
Boolean, The stored bit.
r� r� r s r �get_flagzUrScript.get_flag r� r c �p � |r| j � | j j j |� S )aW
Get standard analog input signal level
See also get tool analog in.
Parameters:
n: The number (id) of the input, integer: [0:1]
wait (bool): If True, waits for next data packet before returning. (Default True)
Return Value:
boolean, The signal level.
)r� r r
�StandardAnalogInput�r r r& s r �get_standard_analog_inz UrScript.get_standard_analog_in! s- � �
� �I�I�K��"�"�-�-�A�A�!�D�Dr c �� � |dk( r2|r| j � | j j j S |dk( r3|r0| j � | j j j S yt d� �)a&
Get standard analog output level
Parameters:
n: The number (id) of the input, integer: [0:1]
wait (bool): If True, waits for next data packet before returning. (Default True)
Return Value:
float, The signal level [0;1]
r r zIndex out of rangeN)r� r r
�StandardAnalogOutput0�StandardAnalogOutput1�KeyErrorr$ s r �get_standard_analog_outz UrScript.get_standard_analog_out3 sm � �
��6��� � � ��&�&�1�1�G�G� G�
�!�V��� � � ��*�*�5�5�K�K�K� � �/�0� 0r c �L � | j j j |� S )a�
Get standard digital input signal level
See also get configurable digital in and get tool digital in.
Parameters:
n (int): The number (id) of the input, integer: [0:7]
wait (bool): If True, waits for next data packet before returning. (Default True)
Return Value:
boolean, The signal level.
)r r
�DigitalInputBitsr$ s r �get_standard_digital_inz UrScript.get_standard_digital_inI s! � � �"�"�-�-�>�>�q�A�Ar c �L � | j j j |� S )a"
Get standard digital output signal level
See also get configurable digital out and get tool digital out.
Parameters:
n: The number (id) of the input, integer: [0:7]
Return Value:
boolean, The signal level.
)r r
�DigitalOutputBitsr s r �get_standard_digital_outz!UrScript.get_standard_digital_outX s! � � �"�"�-�-�?�?��B�Br c � � t d� �)z�
Get tool analog input level
See also get standard analog in.
Parameters:
n: The number (id) of the input, integer: [0:1]
Return Value:
float, The signal level [0,1]
r� r� r s r �get_tool_analog_inzUrScript.get_tool_analog_ing r� r c � � t d� �)a'
Get tool digital input signal level
See also get configurable digital in and
get standard digital in.
Parameters:
n: The number (id) of the input, integer: [0:1]
Return Value:
boolean, The signal level.
r� r� r s r �get_tool_digital_inz UrScript.get_tool_digital_inu r� r c � � t d� �)a+
Get tool digital output signal level
See also get standard digital out and
get configurable digital out.
Parameters:
n: The number (id) of the output, integer: [0:1]
Return Value:
boolean, The signal level.
r� r� r s r �get_tool_digital_outz UrScript.get_tool_digital_out� r� r c � � t d� �)a�
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: A string specifying the IP address of the modbus unit
to which the modbus signal is connected.
slave_number: 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.
r� r� )r �IP� slave_number�signal_address� signal_type� signal_names r �modbus_add_signalzUrScript.modbus_add_signal� � � �2 "�"@�A�Ar c � � t d� �)z�
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.
r� r� )r r< s r �modbus_delete_signalz UrScript.modbus_delete_signal� r� r c � � t d� �)aa
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 or a boolean. For digital signals: True or False. For
register signals: The register value expressed as an unsigned
integer.
r� r� )r r< �is_secondary_programs r �modbus_get_signal_statusz!UrScript.modbus_get_signal_status� r� r c � � t d� �)a
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: A string specifying the IP address locating the modbus
unit to which the custom command should be send.
slave_number: 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.
r� r� )r r8 r9 �
function_code�datas r �modbus_send_custom_commandz#UrScript.modbus_send_custom_command� s � �6 "�"@�A�Ar c � � t d� �)a�
Sets the output register signal identified by the given name to the given
value.
>>> modbus set output register("output1",300,False)
Parameters:
signal_name: A string identifying an output register signal that in advance has been added.
register_value: An integer which must be a valid word (0-65535) value.
is_secondary_program: A boolean for interal use only. Must be set to False.
r� r� )r r< �register_valuerB s r �modbus_set_output_registerz#UrScript.modbus_set_output_register� r� r c � � t d� �)a�
Sets the output digital signal identified by the given name to the given
value.
>>> modbus set output signal("output2",True,False)
Parameters:
signal_name: A string identifying an output digital signal that in advance has been added.
digital_value: A boolean to which value the signal will be set.
is_secondary_program: A boolean for interal use only. Must be set to False.
r� r� )r r< �
digital_valuerB s r �modbus_set_output_signalz!UrScript.modbus_set_output_signal� r� r c � � t d� �)a
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.
>>> modbus 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.
r� r� )r r< �runstate_choices r �$modbus_set_runstate_dependent_choicez-UrScript.modbus_set_runstate_dependent_choice r� r c � � t d� �)a�
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 0-125 specifying the update frequency in Hz.
r� r� )r r< �update_frequencys r �"modbus_set_signal_update_frequencyz+UrScript.modbus_set_signal_update_frequency r� r c � � t d� �)a�
Reads the boolean from one of the input registers, which can also be
accessed by a Field bus. Note, uses it's own memory space.
>>> bool val = read input boolean register(3)
Parameters:
address: Address of the register (0:63)
Return Value:
The boolean value held by the register (True, False)
r� r� �r �addresss r �read_input_boolean_registerz$UrScript.read_input_boolean_register r� r c � � t d� �)ap
Reads the float from one of the input registers, which can also be
accessed by a Field bus. Note, uses it's own memory space.
>>> float val = read input float register(3)
Parameters:
address: Address of the register (0:23)
Return Value:
The value held by the register (float)
r� r� rU s r �read_input_float_registerz"UrScript.read_input_float_register/ r� r c � � t d� �)a�
Reads the integer from one of the input registers, which can also be
accessed by a Field bus. Note, uses it's own memory space.
>>> int val = read input integer register(3)
Parameters:
address: Address of the register (0:23)
Return Value:
The value held by the register [-2,147,483,648 : 2,147,483,647]
r� r� rU s r �read_input_integer_registerz$UrScript.read_input_integer_register> r� r c � � t d� �)a�
Reads the boolean from one of the output registers, which can also be
accessed by a Field bus. Note, uses it's own memory space.
>>> bool val = read output boolean register(3)
Parameters:
address: Address of the register (0:63)
Return Value:
The boolean value held by the register (True, False)
r� r� rU s r � read_output_boolean_registerz%UrScript.read_output_boolean_registerM r� r c � � t d� �)ar
Reads the float from one of the output registers, which can also be
accessed by a Field bus. Note, uses it's own memory space.
>>> float val = read output float register(3)
Parameters:
address: Address of the register (0:23)
Return Value:
The value held by the register (float)
r� r� rU s r �read_output_float_registerz#UrScript.read_output_float_register\ r� r c � � t d� �)a�
Reads the integer from one of the output registers, which can also be
accessed by a Field bus. Note, uses it's own memory space.
>>> int val = read output integer register(3)
Parameters:
address: Address of the register (0:23)
Return Value:
The int value held by the register [-2,147,483,648 :
2,147,483,647]
r� r� rU s r � read_output_integer_registerz%UrScript.read_output_integer_registerk r� r c � � t d� �)aY
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)
r� r� rU s r �
read_port_bitzUrScript.read_port_bit{ r� r c � � t d� �)ao
Reads one of the ports, which can also be accessed by Modbus clients
>>> intval = read port register(3)
Parameters:
address: Address of the port (See portmap on Support site,
page "UsingModbusServer" )
Return Value:
The signed integer value held by the port (-32768 : 32767)
r� r� rU s r �read_port_registerzUrScript.read_port_register� r� r c � � t d� �)aE
Creates a new Remote Procedure Call (RPC) handle. Please read the
subsection ef{Remote Procedure Call (RPC)} for a more detailed
description of RPCs.
>>> proxy = rpc factory("xmlrpc", "http://127.0.0.1:8080/RPC2")
Parameters
rpcType: The type of RPC backed to use. Currently only the "xmlrpc" protocol is available.
url: The URL to the RPC server. Currently two protocols are
supported: pstream and http. The pstream URL looks
like "<ip-address>:<port>", for instance
"127.0.0.1:8080" to make a local connection on port
8080. A http URL generally looks like
"http://<ip-address>:<port>/<path>", whereby the
<path> depends on the setup of the http server. In
the example given above a connection to a local
Python webserver on port 8080 is made, which
expects XMLRPC calls to come in on the path
"RPC2".
Return Value:
A RPC handle with a connection to the specified server using
the designated RPC backend. If the server is not available
the function and program will fail. Any function that is made
available on the server can be called using this instance. For
example "bool isTargetAvailable(int number, ...)" would be
"proxy.isTargetAvailable(var 1, ...)", whereby any number of
arguments are supported (denoted by the ...).
Note: Giving the RPC instance a good name makes programs much
more readable (i.e. "proxy" is not a very good name).
r� r� )r �rpcType�urls r � rpc_factoryzUrScript.rpc_factory� s � �D "�"@�A�Ar c � � t d� �)a�
This function will activate a watchdog for a particular input variable to
the RTDE. When the watchdog did not receive an input update for the
specified variable in the time period specified by min frequency (Hz),
the corresponding action will be taken. All watchdogs are removed on
program stop.
>>> rtde set watchdog("input int register 0", 10, "stop")
Parameters:
variable name: Input variable name (string), as specified
by the RTDE interface
min frequency: The minimum frequency (float) an input
update is expected to arrive.
action: Optional: Either "ignore", "pause" or
"stop" the program on a violation of the
minimum frequency. The default action is
"pause".
Return Value:
None
Note: Only one watchdog is necessary per RTDE input package to
guarantee the specified action on missing updates.
r� r� )r �
variable_name�
min_frequency�actions r �rtde_set_watchdogzUrScript.rtde_set_watchdog� r> r c � � t d� �)at
Deprecated: Set range of analog inputs
Port 0 and 1 is in the controller box, 2 and 3 is in the tool connector.
Parameters:
port: analog input port number, 0,1 = controller, 2,3 = tool
inputRange: Controller analog input range 0: 0-5V (maps
automatically onto range 2) and range 2: 0-10V.
inputRange: Tool analog input range 0: 0-5V (maps
automatically onto range 1), 1: 0-10V and 2:
4-20mA.
Deprecated: The set standard analog input domain and
set tool analog input domain replace this function. Ports 2-3 should
be changed to 0-1 for the latter function. This function might be
removed in the next major release.
Note: For Controller inputs ranges 1: -5-5V and 3: -10-10V are no longer
supported and will show an exception in the GUI.
r� r� )r �port�
inputRanges r �set_analog_inputrangez UrScript.set_analog_inputrange� s � �( "�"@�A�Ar c � � t d� �)z�
Set domain of analog outputs
Parameters:
port: analog output port number
domain: analog output domain: 0: 4-20mA, 1: 0-10V
r� r� �r rp �domains r �set_analog_outputdomainz UrScript.set_analog_outputdomain� s � � "�"@�A�Ar c �, � |rS| j j j dd|z � | j j j dd|z � nO| j j j dd|z � | j j j dd� | j j j � | j j j dd� | j j j dd� y)a
Set configurable digital output signal level
See also set standard digital out and set tool digital out.
Parameters:
n: The number (id) of the output, integer: [0:7]
b: The signal level. (boolean)
� configurable_digital_output_maskrC �configurable_digital_outputr N�r �RTDE�setData�sendData�r r �bs r � set_configurable_digital_outz%UrScript.set_configurable_digital_out� s� � �
� � � � $� $� ,� ,�-O�QR�VW�QW� X� � � � $� $� ,� ,�-J�A�QR�F� S� � � � $� $� ,� ,�-O�QR�VW�QW� X� � � � $� $� ,� ,�-J�A� N� ��� � �)�)�+� ��� � �(�(�)K�Q�O� ��� � �(�(�)F��Jr c � � t d� �)a�
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://universal-robots.com/support 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
r� r� )r r � signal_values r �set_euromap_outputzUrScript.set_euromap_output
r� r c � � t d� �)a[
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://universal-robots.com/support for signal
specifications.
>>> set euromap 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.
r� r� )r r rO s r �%set_euromap_runstate_dependent_choicez.UrScript.set_euromap_runstate_dependent_choice r� r c � � t d� �)z�
Flags behave like internal digital outputs. The keep information
between program runs.
Parameters:
n: The number (id) of the flag, integer: [0:32]
b: The stored bit. (boolean)
r� r� r~ s r �set_flagzUrScript.set_flag/ r� r c � � t d� �)as
Sets the output signal levels depending on the state of the program
(running or stopped).
Example: Set configurable digital output 5 to high when program is not
running.
>>> set runstate configurable digital output to value(5, 2)
Parameters:
outputId: The output signal number (id), integer: [0:7]
state: The state of the output, integer: 0 = Preserve
state, 1 = Low when program is not running, 2 =
High when program is not running, 3 = High
when program is running and low when it is
stopped.
r� r� �r �outputId�states r �1set_runstate_configurable_digital_output_to_valuez:UrScript.set_runstate_configurable_digital_output_to_value: r� r c � � t d� �)a_
Sets the output signal levels depending on the state of the program
(running or stopped).
Example: Set standard analog output 1 to high when program is not
running.
>>> set runstate standard analog output to value(1, 2)
Parameters:
outputId: The output signal number (id), integer: [0:1]
state: The state of the output, integer: 0 = Preserve
state, 1 = Min when program is not running, 2 =
Max when program is not running, 3 = Max when
program is running and Min when it is stopped.
r� r� r� s r �,set_runstate_standard_analog_output_to_valuez5UrScript.set_runstate_standard_analog_output_to_valueN r� r c � � t d� �)aa
Sets the output signal levels depending on the state of the program
(running or stopped).
Example: Set standard digital output 5 to high when program is not
running.
>>> set runstate standard digital output to value(5, 2)
Parameters
outputId: The output signal number (id), integer: [0:7]
state: The state of the output, integer: 0 = Preserve
state, 1 = Low when program is not running, 2 =
High when program is not running, 3 = High
when program is running and low when it is
stopped.
r� r� r� s r �-set_runstate_standard_digital_output_to_valuez6UrScript.set_runstate_standard_digital_output_to_valuea r� r c � � t d� �)a[
Sets the output signal levels depending on the state of the program
(running or stopped).
Example: Set tool digital output 1 to high when program is not running.
>>> set runstate tool digital output to value(1, 2)
Parameters:
outputId: The output signal number (id), integer: [0:1]
state: The state of the output, integer: 0 = Preserve
state, 1 = Low when program is not running, 2 =
High when program is not running, 3 = High
when program is running and low when it is
stopped.
r� r� r� s r �)set_runstate_tool_digital_output_to_valuez2UrScript.set_runstate_tool_digital_output_to_valuet r� r c � � t d� �)a
Set domain of standard analog inputs in the controller box
For the tool inputs see set tool analog input domain.
Parameters:
port: analog input port number: 0 or 1
domain: analog input domains: 0: 4-20mA, 1: 0-10V
r� r� rt s r � set_standard_analog_input_domainz)UrScript.set_standard_analog_input_domain� r� r c � � t d� �)z�
Set standard analog output level
Parameters
n: The number (id) of the input, integer: [0:1]
f: The relative signal level [0;1] (float)
r� r� )r r �fs r �set_standard_analog_outz UrScript.set_standard_analog_out� s � � "�"@�A�Ar c �, � |rS| j j j dd|z � | j j j dd|z � nO| j j j dd|z � | j j j dd� | j j j � | j j j dd� | j j j dd� y)a
Set standard digital output signal level
See also set configurable digital out and set tool digital out.
Parameters:
n: The number (id) of the input, integer: [0:7]
b: The signal level. (boolean)
� standard_digital_output_maskrC �standard_digital_outputr Nrz r~ s r �set_standard_digital_outz!UrScript.set_standard_digital_out� s� � �
� � � � $� $� ,� ,�-K�Q�RS�V� T� � � � $� $� ,� ,�-F��Q�� O� � � � $� $� ,� ,�-K�Q�RS�V� T� � � � $� $� ,� ,�-F�� J� ��� � �)�)�+� ��� � �(�(�)G��K� ��� � �(�(�)B�A�Fr c � � t d� �)a
Set domain of analog inputs in the tool
For the controller box inputs see set standard analog input domain.
Parameters:
port: analog input port number: 0 or 1
domain: analog input domains: 0: 4-20mA, 1: 0-10V
r� r� rt s r � set_tool_analog_input_domainz%UrScript.set_tool_analog_input_domain� r� r c � � t d� �)a
Set tool digital output signal level
See also set configurable digital out and
set standard digital out.
Parameters:
n: The number (id) of the output, integer: [0:1]
b: The signal level. (boolean)
r� r� r~ s r �set_tool_digital_outz UrScript.set_tool_digital_out� r� r c � � t d� �)a<
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,
integer: 0, 12 or 24.
r� r� )r �voltages r �set_tool_voltagezUrScript.set_tool_voltage� r� r c � � y)ad
Writes the boolean value into one of the output registers, which can
also be accessed by a Field bus. Note, uses it's own memory space.
>>> write output boolean register(3, True)
Parameters:
address: Address of the register (0:63)
value: Value to set in the register (True, False)
Nr( �r rV �values r � write_output_boolean_registerz&UrScript.write_output_boolean_register� s � r c � � t d� �)a[
Writes the float value into one of the output registers, which can also
be accessed by a Field bus. Note, uses it's own memory space.
>>> write output float register(3, 37.68)
Parameters:
address: Address of the register (0:23)
value: Value to set in the register (float)
r� r� r� s r �write_output_float_registerz$UrScript.write_output_float_register� r� r c � � t d� �)a}
Writes the integer value into one of the output registers, which can also
be accessed by a Field bus. Note, uses it's own memory space.
>>> write output integer register(3, 12)
Parameters:
address: Address of the register (0:23)
value: Value to set in the register [-2,147,483,648 :
2,147,483,647]
r� r� r� s r � write_output_integer_registerz&UrScript.write_output_integer_register� r� r c � � t d� �)aC
Writes one of the ports, which can also be accessed by Modbus clients
>>> write port bit(3,True)
Parameters:
address: Address of the port (See portmap on Support site,
page "UsingModbusServer" )
value: Value to be set in the register (True, False)
r� r� r� s r �write_port_bitzUrScript.write_port_bit� r� r c � � t d� �)a]
Writes one of the ports, which can also be accessed by Modbus clients
>>> write port register(3,100)
Parameters:
address: Address of the port (See portmap on Support site,
page "UsingModbusServer" )
value: Value to be set in the port (0 : 65536) or (-32768 :
32767)
r� r� r� s r �write_port_registerz UrScript.write_port_register
r� r )F)N�ffffff�?g�������?r r TN)N� �?� �?r r TN)N�333333�?r� r TN)NNr� r� r TNN) Nr� r� r r TNNN)r� r� r T)g����Mb�?g�������?�d T)T)r T)r� r NT)r� T)� r" T)g�������?T)r T)�PopupFF)rA )�pause)ur� r� � __qualname__�__doc__r r r2 r5 r9 r? r* r^ rd rg rk rn rq rv rx rz r} r r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r� r � staticmethodr r r r r r! r% r* r- r0 r2 r4 r6 r= r@ rC rG rJ rM rP rS rW rY r[ r] r_ ra rc re ri rn rr rv r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r( r r r r s� � ��, >�C� +�B+�6+�6 +�BB�H %=�Oa�2�1�EY�`e�oq�0+�d �+�&+�,+�& +� +�> +� +�&
�+�$
�$+�L+�0F�&+� +�2+�,+� .L�RV� +�( +� +� +� +�$ B�8�67�"
>�2
?� B� B� (J�\b�,2�B�(
B�
B�
B�
B� B� B� ?�$ B� B�B�$B�& B� B� +�4B�4+�4+�,�,� � B� �� ��4 G�
H� B� B�$ B�E�$1�,
B�
C� B�
B�
B� B�6 B�B�(B�: B� B� B� B�
B�
B�
B�
B�
B� B�
B�
B� "B�HB�6B�,B�K�*
B� B�& B�B�(B�&B�&B�&
B�B�G�*
B� B�
B�
� B� B� B� Br r )
�ctypes�
__author__�
__copyright__� __license__r �numpyrE r
�objectr r( r r �<module>r� s0 ��
�
�
�%�
�� � � � �J B�v� J Br
