Data streaming

Data described below are sent by the robot controller at 10Hz by the TCP/IP Primary (and Secondary) Interface protocol.

Start/Stop streaming

You can enable or disable data streaming at any time with the following methods:

// Starts data streaming and the possibility to send scripts to the robot.
public void EnableDataStreaming(DataStreamingPorts port = DataStreamingPorts.PrimaryClient)
// Stops data streaming and the possibility to send scripts to the robot.
public void DisableDataStreaming()

You can then check if data streaming is enabled with the following property :

// Return True if the connection to the robot is active
public bool DataStreamingEnabled { get; }

If you want to know with which of your local IP addresses you are connected to the robot, you can use the DataStreamingLocalEndPoint property.

// Indicates the current local endpoint (i.e. IP Address) used to communicate with the robot. You can use this IP in your UR script in the function rpc_factory()
public IPEndPoint DataStreamingLocalEndPoint { get; }

Try it with the Windows example

Robot mode

private UR ur;
private void Start() {
ur = new UR(); // Create a new UR instance
ur.Connect("192.168.0.1"); // Connect to the robot
// ...
// Direct access to last received package
RobotModeDataPackageEventArgs _lastRobotModeData = ur.RobotModeData;
// Attach a delegate to the event triggered when new package comes
ur.RobotModeDataReceived += Ur_RobotModeDataReceived;
}
private void Ur_RobotModeDataReceived(object sender, RobotModeDataPackageEventArgs e) {
// e contains the incoming package
}
Members of RobotModeDataPackageEventArgs :
public class RobotModeDataPackageEventArgs : PackageEventArgs {
// Current robot control mode
[PackageDescription("Current robot control mode")]
public ControlModes ControlMode { get; set; },
// The button Emergency Stop is pressed
[PackageDescription("The button Emergency Stop is pressed")]
public bool EmergencyStopped { get; set; },
// Robot is connected to its controller
[PackageDescription("Robot is connected to its controller")]
public bool PhysicalRobotConnected { get; set; },
// The running program is paused
[PackageDescription("The running program is paused")]
public bool ProgramPaused { get; set; },
// A program is running
[PackageDescription("A program is running")]
public bool ProgramRunning { get; set; },
// A stop occured due to a fault detection
[PackageDescription("A stop occured due to a fault detection")]
public bool ProtectiveStopped { get; set; },
// Real robot mode active. False if robot is in simulation
[PackageDescription("Real robot mode active. False if robot is in simulation")]
public bool RealRobotEnabled { get; set; },
// Current robot running mode
[PackageDescription("Current robot running mode")]
public RobotModes RobotMode { get; set; },
// Robot is powered on and boot is completed. If false, you need to press "ON" button to power it on
[PackageDescription("Robot is powered on and boot is completed. If false, you need to press \"ON\" button to power it on")]
public bool RobotPowerOn { get; set; },
// Speed scaling
[PackageDescription("Speed scaling")]
public double SpeedScaling { get; set; },
// Overriden speed ratio between 0 (0%) and 1 (100%)
[PackageDescription("Overriden speed ratio between 0 (0%) and 1 (100%)")]
public double TargetSpeedFraction { get; set; },
// Maximum target speed fraction
[PackageDescription("Maximum target speed fraction")]
public double TargetSpeedFractionLimit { get; set; },
// Timespan since the robot controller has started
[PackageDescription("Timespan since the robot controller has started")]
public TimeSpan Timestamp { get; set; }
}
Members of ControlModes :
public enum ControlModes {
// Robot is force controlled. (For example : URScript force_mode() function is called)
Force = 2,
// Robot is position controlled
Position = 0,
// The robot is hand guided by pushing teached button
Teach = 1,
// Robot is torque controlled
Torque = 3
}
Members of RobotModes :
public enum RobotModes {
// The robot is hand guided by pushing teached button
BackDrive = 6,
// The robot controller is booting
Booting = 2,
// Robot has stopped due to a Safety Stop
ConfirmSafety = 1,
// Robot is not connected to its controller
Disconnected = 0,
// Power is on but breaks are not released
Idle = 5,
// Robot is in an obsolete CB2 mode
Other = -1,
// The robot is powered off
PowerOff = 3,
// The robot is powered on
PowerOn = 4,
// Robot is in normal mode
Running = 7,
// Firmware is upgrading
UpdatingFirmware = 8
}

Joint data

private UR ur;
private void Start() {
ur = new UR(); // Create a new UR instance
ur.Connect("192.168.0.1"); // Connect to the robot
// ...
// Direct access to last received package
JointDataPackageEventArgs _lastJointData = ur.JointData;
// Attach a delegate to the event triggered when new package comes
ur.JointDataReceived += Ur_JointDataReceived;
}
private void Ur_JointDataReceived(object sender, JointDataPackageEventArgs e) {
// e contains the incoming package
}
Members of JointDataPackageEventArgs :
public class JointDataPackageEventArgs : PackageEventArgs {
// Base joint data
[PackageDescription("Base joint data")]
public JointData Base { get; set; },
// Elbow joint data
[PackageDescription("Elbow joint data")]
public JointData Elbow { get; set; },
// Shoulder joint data
[PackageDescription("Shoulder joint data")]
public JointData Shoulder { get; set; },
// Wrist1 joint data
[PackageDescription("Wrist1 joint data")]
public JointData Wrist1 { get; set; },
// Wrist2 joint data
[PackageDescription("Wrist2 joint data")]
public JointData Wrist2 { get; set; },
// Wrist3 (Tool) joint data
[PackageDescription("Wrist3 (Tool) joint data")]
public JointData Wrist3 { get; set; }
}
![](/universal-robots/joints.png)Members of JointData :
public class JointData {
// Joint rotation speed in rad/s
[PackageDescription("Joint rotation speed in rad/s", PackageUnit.RadianPerSecond)]
public double ActualSpeed { get; set; },
// Motor current in Amps
[PackageDescription("Motor current in Amps", PackageUnit.Amp)]
public float Current { get; set; },
// Joint mode
[PackageDescription("Joint mode")]
public JointModes JointMode { get; set; },
// Angular joint position in radian
[PackageDescription("Angular joint position in radian", PackageUnit.Radian)]
public double Position { get; set; },
// Angular target position in radian
[PackageDescription("Angular target position in radian", PackageUnit.Radian)]
public double TargetPosition { get; set; },
// Joint temperature in °C
[PackageDescription("Joint temperature in °C", PackageUnit.CelciusDegree)]
public float Temperature { get; set; },
// Motor votage in Volts
[PackageDescription("Motor votage in Volts", PackageUnit.Volt)]
public float Voltage { get; set; }
}
Members of JointModes :
public enum JointModes : byte {
Backdrive = 238,
Booting = 247,
Bootloder = 249,
Calibration = 250,
Fault = 252,
Idle = 255,
MotorInitialisation = 246,
NotResponding = 245,
PartDCalibration = 237,
PartDCalibrationError = 248,
PowerOff = 239,
Running = 253,
ShuttingDown = 236
}

Tool data

private UR ur;
private void Start() {
ur = new UR(); // Create a new UR instance
ur.Connect("192.168.0.1"); // Connect to the robot
// ...
// Direct access to last received package
ToolDataPackageEventArgs _lastToolData = ur.ToolData;
// Attach a delegate to the event triggered when new package comes
ur.ToolDataReceived += Ur_ToolDataReceived;
}
private void Ur_ToolDataReceived(object sender, ToolDataPackageEventArgs e) {
// e contains the incoming package
}
Members of ToolDataPackageEventArgs :
public class ToolDataPackageEventArgs : PackageEventArgs {
// Value of Analog input 2 (analog_in[2])
[PackageDescription("Value of Analog input 2 (analog_in[2])")]
public double AnalogInput2 { get; set; },
// Value of Analog input 3 (analog_in[3])
[PackageDescription("Value of Analog input 3 (analog_in[3])")]
public double AnalogInput3 { get; set; },
// Unit of analog input 2 (analog_in[2])
[PackageDescription("Unit of analog input 2 (analog_in[2])")]
public AnalogRanges AnalogInputRange2 { get; set; },
// Unit of analog input 3 (analog_in[3])
[PackageDescription("Unit of analog input 3 (analog_in[3])")]
public AnalogRanges AnalogInputRange3 { get; set; },
// Tool current in Amps
[PackageDescription("Tool current in Amps", PackageUnit.Amp)]
public float ToolCurrent { get; set; },
// Tool mode
[PackageDescription("Tool mode")]
public ToolModes ToolMode { get; set; },
// Tool output voltage
[PackageDescription("Tool output voltage", PackageUnit.Volt)]
public sbyte ToolOutputVoltage { get; set; },
// Tool Temperature in °C
[PackageDescription("Tool Temperature in °C", PackageUnit.CelciusDegree)]
public float ToolTemperature { get; set; },
// Actual robot voltage power supply
[PackageDescription("Actual robot voltage power supply", PackageUnit.Volt)]
public float ToolVoltage48V { get; set; }
}
Members of AnalogRanges :
public enum AnalogRanges {
// The analog value is in Amps (A)
Current = 0,
// The analog value is in Volts (V)
Voltage = 1
}
Members of ToolModes :
public enum ToolModes : byte {
// Bootloader
Bootloader = 249,
// Idle
Idle = 255,
// Running
Running = 253
}

Masterboard data

private UR ur;
private void Start() {
ur = new UR(); // Create a new UR instance
ur.Connect("192.168.0.1"); // Connect to the robot
// ...
// Direct access to last received package
MasterboardDataPackageEventArgs _lastMasterboardData = ur.MasterboardData;
// Attach a delegate to the event triggered when new package comes
ur.MasterboardDataReceived += Ur_MasterboardDataReceived;
}
private void Ur_MasterboardDataReceived(object sender, MasterboardDataPackageEventArgs e) {
// e contains the incoming package
}
Members of MasterboardDataPackageEventArgs :
public class MasterboardDataPackageEventArgs : PackageEventArgs {
// Value of analog input 0 (analog_in[0])
[PackageDescription("Value of analog input 0 (analog_in[0])")]
public double AnalogInput0 { get; set; },
// Value of analog input 1 (analog_in[1])
[PackageDescription("Value of analog input 1 (analog_in[1])")]
public double AnalogInput1 { get; set; },
// Unit of analog input 0 (analog_in[0])
[PackageDescription("Unit of analog input 0 (analog_in[0])")]
public AnalogRanges AnalogInputRange0 { get; set; },
// Unit of analog input 1 (analog_in[1])
[PackageDescription("Unit of analog input 1 (analog_in[1])")]
public AnalogRanges AnalogInputRange1 { get; set; },
// Value of analog output 0 (analog_out[0])
[PackageDescription("Value of analog output 0 (analog_out[0])")]
public double AnalogOutput0 { get; set; },
// Value of analog output 1 (analog_out[1])
[PackageDescription("Value of analog output 1 (analog_out[1])")]
public double AnalogOutput1 { get; set; },
// Unit of analog output 0 (analog_out[0])
[PackageDescription("Unit of analog output 0 (analog_out[0])")]
public AnalogRanges AnalogOutputDomain0 { get; set; },
// Unit of analog output 1 (analog_out[1)
[PackageDescription("Unit of analog output 1 (analog_out[1)")]
public AnalogRanges AnalogOutputDomain1 { get; set; },
// Register where each bit is a digital input value
[PackageDescription("Register where each bit is a digital input value")]
public MasterboardDigitalIO DigitalInputs { get; set; },
// Register where each bit is a digital output value
[PackageDescription("Register where each bit is a digital output value")]
public MasterboardDigitalIO DigitalOutputs { get; set; },
// The robot is interfaced to injection molding machines Euromap 67
[PackageDescription("The robot is interfaced to injection molding machines Euromap 67")]
public sbyte Euromap67Installed { get; set; },
// Euromap current
[PackageDescription("Euromap current", PackageUnit.Amp)]
public float EuromapCurrent { get; set; },
// Register where each bit is a digital Euromap input
[PackageDescription("Register where each bit is a digital Euromap input")]
public int EuromapInputBits { get; set; },
// Register where each bit is a digital Euromap output
[PackageDescription("Register where each bit is a digital Euromap output")]
public int EuromapOutputBits { get; set; },
// Euromap votage
[PackageDescription("Euromap votage", PackageUnit.Volt)]
public float EuromapVoltage { get; set; },
// Robot is in reduced speed mode
[PackageDescription("Robot is in reduced speed mode")]
public byte InReducedMode { get; set; },
// Temperature of masterboard in °C
[PackageDescription("Temperature of masterboard in °C", PackageUnit.CelciusDegree)]
public float MasterboardTemperature { get; set; },
// Current of all digital and analog inputs and outputs
[PackageDescription("Current of all digital and analog inputs and outputs", PackageUnit.Amp)]
public float MasterIOCurrent { get; set; },
// Position of operational mode selector input switch
[PackageDescription("Position of operational mode selector input switch")]
public byte OperationalModeSelectorInput { get; set; },
// Robot current consumption in Amps
[PackageDescription("Robot current consumption in Amps", PackageUnit.Amp)]
public float RobotCurrent { get; set; },
// Voltage of internal 48V power supply
[PackageDescription("Voltage of internal 48V power supply", PackageUnit.Volt)]
public float RobotVoltage48V { get; set; },
// Masterboard safety mode
[PackageDescription("Masterboard safety mode")]
public SafetyStatus Safetymode { get; set; },
// Position of the 3-position enabling device
[PackageDescription("Position of the 3-position enabling device")]
public byte ThreePositionEnablingDeviceInput { get; set; }
}
Members of AnalogRanges :
public enum AnalogRanges {
// The analog value is in Amps (A)
Current = 0,
// The analog value is in Volts (V)
Voltage = 1
}
Members of MasterboardDigitalIO :
public class MasterboardDigitalIO {
// Register value seen as a bool array
[PackageDescription("Register value seen as a bool array")]
public BitArray BitArray { get; },
public bool Configurable0 { get; },
public bool Configurable1 { get; },
public bool Configurable2 { get; },
public bool Configurable3 { get; },
public bool Configurable4 { get; },
public bool Configurable5 { get; },
public bool Configurable6 { get; },
public bool Configurable7 { get; },
public bool Digital0 { get; },
public bool Digital1 { get; },
public bool Digital2 { get; },
public bool Digital3 { get; },
public bool Digital4 { get; },
public bool Digital5 { get; },
public bool Digital6 { get; },
public bool Digital7 { get; },
public bool ToolDigital0 { get; },
public bool ToolDigital1 { get; },
// Register value
[PackageDescription("Register value")]
public int Value { get; }
}
Members of SafetyStatus :
public enum SafetyStatus : byte {
AutomaticModeSafeguardStop = 10,
// Safety is in fault mode
Fault = 9,
// Safety is in normal operating conditions
Normal = 1,
// Protective safeguard Stop. This safety function is triggeredby an external protective device using safety inputs which will trigger a Cat 2 stop3per IEC 60204-1.
ProtectiveStop = 3,
// When a safety limit is violated, the safety system must be restarted.
Recovery = 4,
// Speed is reduced
Reduced = 2,
// (EA + EB + SBUS->Screen) Physical e-stop interface input activated
RobotEmergencyStop = 7,
// (SI0 + SI1 + SBUS) Physical s-stop interface input
SafeguardStop = 5,
// (EA + EB + SBUS->Euromap67) Physical e-stop interface input activated
SystemEmergencyStop = 6,
SystemThreePositionEnablingStop = 11,
// Safety is in violation mode (for example, violation of the allowed delay between redundant signals)
Violation = 8
}

Cartesian information

private UR ur;
private void Start() {
ur = new UR(); // Create a new UR instance
ur.Connect("192.168.0.1"); // Connect to the robot
// ...
// Direct access to last received package
CartesianInfoPackageEventArgs _lastCartesianInfo = ur.CartesianInfo;
// Attach a delegate to the event triggered when new package comes
ur.CartesianInfoReceived += Ur_CartesianInfoReceived;
}
private void Ur_CartesianInfoReceived(object sender, CartesianInfoPackageEventArgs e) {
// e contains the incoming package
}
Members of CartesianInfoPackageEventArgs :
public class CartesianInfoPackageEventArgs : PackageEventArgs {
// RX axis coordinate in rad of the TCP in the current frame
[PackageDescription("RX axis coordinate in rad of the TCP in the current frame", PackageUnit.Radian)]
public double Rx { get; set; },
// RY axis coordinate in rad of the TCP in the current frame
[PackageDescription("RY axis coordinate in rad of the TCP in the current frame", PackageUnit.Radian)]
public double Ry { get; set; },
// RZ axis coordinate in rad of the TCP in the current frame
[PackageDescription("RZ axis coordinate in rad of the TCP in the current frame", PackageUnit.Radian)]
public double Rz { get; set; },
// RX position of the TCP in the flange frame in rad
[PackageDescription("RX position of the TCP in the flange frame in rad", PackageUnit.Radian)]
public double TCPOffsetRX { get; set; },
// RY position of the TCP in the flange frame in rad
[PackageDescription("RY position of the TCP in the flange frame in rad", PackageUnit.Radian)]
public double TCPOffsetRY { get; set; },
// RZ position of the TCP in the flange frame in rad
[PackageDescription("RZ position of the TCP in the flange frame in rad", PackageUnit.Radian)]
public double TCPOffsetRZ { get; set; },
// X position of the TCP in the flange frame in meter
[PackageDescription("X position of the TCP in the flange frame in meter", PackageUnit.Meter)]
public double TCPOffsetX { get; set; },
// Y position of the TCP in the flange frame in meter
[PackageDescription("Y position of the TCP in the flange frame in meter", PackageUnit.Meter)]
public double TCPOffsetY { get; set; },
// Z position of the TCP in the flange frame in meter
[PackageDescription("Z position of the TCP in the flange frame in meter", PackageUnit.Meter)]
public double TCPOffsetZ { get; set; },
// X axis coordinate in meter of the TCP in the current frame
[PackageDescription("X axis coordinate in meter of the TCP in the current frame", PackageUnit.Meter)]
public double X { get; set; },
// Y axis coordinate in meter of the TCP in the current frame
[PackageDescription("Y axis coordinate in meter of the TCP in the current frame", PackageUnit.Meter)]
public double Y { get; set; },
// Z axis coordinate in meter of the TCP in the current frame
[PackageDescription("Z axis coordinate in meter of the TCP in the current frame", PackageUnit.Meter)]
public double Z { get; set; }
}
![](/universal-robots/flange-frame-3d.png) ![](/universal-robots/flange-frame-projection.png)

Kinematics information

private UR ur;
private void Start() {
ur = new UR(); // Create a new UR instance
ur.Connect("192.168.0.1"); // Connect to the robot
// ...
// Direct access to last received package
KinematicsInfoPackageEventArgs _lastKinematicsInfo = ur.KinematicsInfo;
// Attach a delegate to the event triggered when new package comes
ur.KinematicsInfoReceived += Ur_KinematicsInfoReceived;
}
private void Ur_KinematicsInfoReceived(object sender, KinematicsInfoPackageEventArgs e) {
// e contains the incoming package
}
Members of KinematicsInfoPackageEventArgs :
public class KinematicsInfoPackageEventArgs : PackageEventArgs {
// Base kinematics info
[PackageDescription("Base kinematics info")]
public JointKinematicsInfo Base { get; set; },
// Calibration status (0 : OK)
[PackageDescription("Calibration status (0 : OK)")]
public int CalibrationStatus { get; set; },
// Elbow kinematics info
[PackageDescription("Elbow kinematics info")]
public JointKinematicsInfo Elbow { get; set; },
// Shoulder kinematics info
[PackageDescription("Shoulder kinematics info")]
public JointKinematicsInfo Shoulder { get; set; },
// Wrist1 kinematics info
[PackageDescription("Wrist1 kinematics info")]
public JointKinematicsInfo Wrist1 { get; set; },
// Wrist2 kinematics info
[PackageDescription("Wrist2 kinematics info")]
public JointKinematicsInfo Wrist2 { get; set; },
// Wrist3 (Tool) kinematics info
[PackageDescription("Wrist3 (Tool) kinematics info")]
public JointKinematicsInfo Wrist3 { get; set; }
}
![](/universal-robots/joints.png)Members of JointKinematicsInfo :
public class JointKinematicsInfo {
// Joint checksum
[PackageDescription("Joint checksum")]
public int Checksum { get; set; },
// DH convention a parameter
[PackageDescription("DH convention a parameter", PackageUnit.Meter)]
public double DHa { get; set; },
// DH convention alpha parameter
[PackageDescription("DH convention alpha parameter", PackageUnit.Radian)]
public double Dhalpha { get; set; },
// DH convention d parameter
[PackageDescription("DH convention d parameter", PackageUnit.Meter)]
public double DHd { get; set; },
// DH convention theta parameter
[PackageDescription("DH convention theta parameter", PackageUnit.Radian)]
public double DHtheta { get; set; }
}

For more information about DH (Denavit-Hartenberg) parameters, please refer the following links :

Configuration data

private UR ur;
private void Start() {
ur = new UR(); // Create a new UR instance
ur.Connect("192.168.0.1"); // Connect to the robot
// ...
// Direct access to last received package
ConfigurationDataPackageEventArgs _lastConfigurationData = ur.ConfigurationData;
// Attach a delegate to the event triggered when new package comes
ur.ConfigurationDataReceived += Ur_ConfigurationDataReceived;
}
private void Ur_ConfigurationDataReceived(object sender, ConfigurationDataPackageEventArgs e) {
// e contains the incoming package
}
Members of ConfigurationDataPackageEventArgs :
public class ConfigurationDataPackageEventArgs : PackageEventArgs {
// Default joint acceleration speed in rad/s²
[PackageDescription("Default joint acceleration speed in rad/s²", PackageUnit.RadianPerSecondSquared)]
public double AJointDefault { get; set; },
// Default TCP acceleration speed in m/s²
[PackageDescription("Default TCP acceleration speed in m/s²", PackageUnit.MeterPersSecondSquared)]
public double AToolDefault { get; set; },
// Base joint configuration
[PackageDescription("Base joint configuration")]
public JointConfiguration Base { get; set; },
// Controller box type
[PackageDescription("Controller box type")]
public ControllerBoxTypes ControllerBoxType { get; set; },
// Elbow joint configuration
[PackageDescription("Elbow joint configuration")]
public JointConfiguration Elbow { get; set; },
// Equipment radius in meter
[PackageDescription("Equipment radius in meter", PackageUnit.Meter)]
public double EqRadius { get; set; },
// Masterboard version
[PackageDescription("Masterboard version")]
public int MasterboardVersion { get; set; },
// Robot serie
[PackageDescription("Robot serie")]
public RobotSubTypes RobotSubType { get; set; },
// Model of the robot (UR3, UR5, UR10, UR16)
[PackageDescription("Model of the robot")]
public RobotModels RobotType { get; set; },
// Shoulder joint configuration
[PackageDescription("Shoulder joint configuration")]
public JointConfiguration Shoulder { get; set; },
// Default joint angular speed in rad/s
[PackageDescription("Default joint angular speed in rad/s", PackageUnit.RadianPerSecond)]
public double VJointDefault { get; set; },
// Default TCP speed speed in m/s
[PackageDescription("Default TCP speed speed in m/s", PackageUnit.MeterPerSecond)]
public double VToolDefault { get; set; },
// Wrist1 joint configuration
[PackageDescription("Wrist1 joint configuration")]
public JointConfiguration Wrist1 { get; set; },
// Wrist2 joint configuration
[PackageDescription("Wrist2 joint configuration")]
public JointConfiguration Wrist2 { get; set; },
// Wrist3 (Tool) joint configuration
[PackageDescription("Wrist3 (Tool) joint configuration")]
public JointConfiguration Wrist3 { get; set; }
}
Members of ControllerBoxTypes :
public enum ControllerBoxTypes {
// UR10 controller box
UR10 = 5,
// UR16 controller box
UR16 = 16,
// UR3 controller box
UR3 = 6,
// UR5 controller box
UR5 = 4
}
Members of JointConfiguration :
public class JointConfiguration {
// a parameter of Denavit–Hartenberg (DH) convention
[PackageDescription("a parameter of Denavit–Hartenberg (DH) convention", PackageUnit.Meter)]
public double DHa { get; set; },
// Alpha parameter of Denavit–Hartenberg (DH) convention
[PackageDescription("Alpha parameter of Denavit–Hartenberg (DH) convention", PackageUnit.Radian)]
public double DHalpha { get; set; },
// d parameter of Denavit–Hartenberg (DH) convention
[PackageDescription("d parameter of Denavit–Hartenberg (DH) convention", PackageUnit.Meter)]
public double DHd { get; set; },
// Theta parameter of Denavit–Hartenberg (DH) convention
[PackageDescription("Theta parameter of Denavit–Hartenberg (DH) convention", PackageUnit.Radian)]
public double DHtheta { get; set; },
// Maximum rotation speed in rad/s²
[PackageDescription("Maximum rotation speed in rad/s²", PackageUnit.RadianPerSecondSquared)]
public double JointMaxAcceleration { get; set; },
// Maximum angular position in rad
[PackageDescription("Maximum angular position in rad", PackageUnit.Radian)]
public double JointMaxLimit { get; set; },
// Maximum rotation speed in rad/s
[PackageDescription("Maximum rotation speed in rad/s", PackageUnit.RadianPerSecond)]
public double JointMaxSpeed { get; set; },
// Minimum angular position in rad
[PackageDescription("Minimum angular position in rad", PackageUnit.Radian)]
public double JointMinLimit { get; set; }
}
Members of RobotSubTypes :
public enum RobotSubTypes {
// CB2-series (Firmware 1.x)
CB2Serie = 1,
// CB3-series (Firmware 3.x)
CB3Serie = 2,
// e-series (Firmware 5.x)
ESerie = 3
}
Members of RobotModels :
public enum RobotModels {
UR10 = 2,
UR16 = 4,
UR3 = 3,
UR5 = 1
}
## Force mode data
private UR ur;
private void Start() {
ur = new UR(); // Create a new UR instance
ur.Connect("192.168.0.1"); // Connect to the robot
// ...
// Direct access to last received package
ForceModeDataPackageEventArgs _lastForceModeData = ur.ForceModeData;
// Attach a delegate to the event triggered when new package comes
ur.ForceModeDataReceived += Ur_ForceModeDataReceived;
}
private void Ur_ForceModeDataReceived(object sender, ForceModeDataPackageEventArgs e) {
// e contains the incoming package
}
Members of ForceModeDataPackageEventArgs :
public class ForceModeDataPackageEventArgs : PackageEventArgs {
// Dexterity of the robot
public double RobotDexterity { get; set; },
// Rx torque in tool frame in Nm
public double Rx { get; set; },
// Ry torque in tool frame in Nm
public double Ry { get; set; },
// Rz torque in tool frame in Nm
public double Rz { get; set; },
// X force in tool frame in N
public double X { get; set; },
// Y force in tool frame in N
public double Y { get; set; },
// Z force in tool frame in N
public double Z { get; set; }
}

Additional information

private UR ur;
private void Start() {
ur = new UR(); // Create a new UR instance
ur.Connect("192.168.0.1"); // Connect to the robot
// ...
// Direct access to last received package
AdditionalInfoPackageEventArgs _lastAdditionalInfo = ur.AdditionalInfo;
// Attach a delegate to the event triggered when new package comes
ur.AdditionalInfoReceived += Ur_AdditionalInfoReceived;
}
private void Ur_AdditionalInfoReceived(object sender, AdditionalInfoPackageEventArgs e) {
// e contains the incoming package
}
Members of AdditionalInfoPackageEventArgs :
public class AdditionalInfoPackageEventArgs : PackageEventArgs {
// The free drive button is enabled
[PackageDescription("The free drive button is enabled")]
public bool FreedriveButtonEnabled { get; set; },
// The free drive button is pressed
[PackageDescription("The free drive button is pressed")]
public bool FreedriveButtonPressed { get; set; },
// Free drive is enable via IO
[PackageDescription("Free drive is enable via IO")]
public bool IOEnabledFreedrive { get; set; }
}

Calibration data

private UR ur;
private void Start() {
ur = new UR(); // Create a new UR instance
ur.Connect("192.168.0.1"); // Connect to the robot
// ...
// Direct access to last received package
CalibrationDataPackageEventArgs _lastCalibrationData = ur.CalibrationData;
// Attach a delegate to the event triggered when new package comes
ur.CalibrationDataReceived += Ur_CalibrationDataReceived;
}
private void Ur_CalibrationDataReceived(object sender, CalibrationDataPackageEventArgs e) {
// e contains the incoming package
}
Members of CalibrationDataPackageEventArgs :
public class CalibrationDataPackageEventArgs : PackageEventArgs {
// Frx calibration data
[PackageDescription("Frx calibration data")]
public double Frx { get; set; },
// Fry calibration data
[PackageDescription("Fry calibration data")]
public double Fry { get; set; },
// Frz calibration data
[PackageDescription("Frz calibration data")]
public double Frz { get; set; },
// Fx calibration data
[PackageDescription("Fx calibration data")]
public double Fx { get; set; },
// Fy calibration data
[PackageDescription("Fy calibration data")]
public double Fy { get; set; },
// Fz calibration data
[PackageDescription("Fz calibration data")]
public double Fz { get; set; }
}

Safety data

private UR ur;
private void Start() {
ur = new UR(); // Create a new UR instance
ur.Connect("192.168.0.1"); // Connect to the robot
// ...
// Direct access to last received package
SafetyDataPackageEventArgs _lastSafetyData = ur.SafetyData;
// Attach a delegate to the event triggered when new package comes
ur.SafetyDataReceived += Ur_SafetyDataReceived;
}
private void Ur_SafetyDataReceived(object sender, SafetyDataPackageEventArgs e) {
// e contains the incoming package
}
Members of SafetyDataPackageEventArgs :
public class SafetyDataPackageEventArgs : PackageEventArgs {
// Irrelevent (Internal use only)
public byte[] Data { get; set; }
}

Tool communication information

private UR ur;
private void Start() {
ur = new UR(); // Create a new UR instance
ur.Connect("192.168.0.1"); // Connect to the robot
// ...
// Direct access to last received package
ToolCommunicationInfoPackageEventArgs _lastToolCommunicationInfo = ur.ToolCommunicationInfo;
// Attach a delegate to the event triggered when new package comes
ur.ToolCommunicationInfoReceived += Ur_ToolCommunicationInfoReceived;
}
private void Ur_ToolCommunicationInfoReceived(object sender, ToolCommunicationInfoPackageEventArgs e) {
// e contains the incoming package
}
Members of ToolCommunicationInfoPackageEventArgs :
public class ToolCommunicationInfoPackageEventArgs : PackageEventArgs {
// Baude rate
[PackageDescription("Baude rate")]
public int BaudRate { get; set; },
// Parity
[PackageDescription("Parity")]
public int Parity { get; set; },
// RX Idle Chars
[PackageDescription("RX Idle Chars")]
public float RxIdleChars { get; set; },
// Stop bits
[PackageDescription("Stop bits")]
public int StopBits { get; set; },
// Is the tool communication interface enabled
[PackageDescription("Is the tool communication interface enabled")]
public bool ToolCommunicationIsEnabled { get; set; },
// TX Idle Chars
[PackageDescription("TX Idle Chars")]
public float TxIdleChars { get; set; }
}

Tool mode

private UR ur;
private void Start() {
ur = new UR(); // Create a new UR instance
ur.Connect("192.168.0.1"); // Connect to the robot
// ...
// Direct access to last received package
ToolModeInfoPackageEventArgs _lastToolModeInfo = ur.ToolModeInfo;
// Attach a delegate to the event triggered when new package comes
ur.ToolModeInfoReceived += Ur_ToolModeInfoReceived;
}
private void Ur_ToolModeInfoReceived(object sender, ToolModeInfoPackageEventArgs e) {
// e contains the incoming package
}
Members of ToolModeInfoPackageEventArgs :
public class ToolModeInfoPackageEventArgs : PackageEventArgs {
// Digital output 0 configuration
[PackageDescription("Digital output 0 configuration")]
public DigitalOutputConfigurations DigitalOutputMode0 { get; set; },
// Digital output 1 configuration
[PackageDescription("Digital output 1 configuration")]
public DigitalOutputConfigurations DigitalOutputMode1 { get; set; },
// Digital output mode
[PackageDescription("Digital output mode")]
public OutputModes OutputMode { get; set; }
}
Members of DigitalOutputConfigurations :
public enum DigitalOutputConfigurations {
// Push / Pull
PushPull = 3,
// Sinking (NOPN)
SinkingNPN = 1,
// Sourcing (PNP)
SourcingPNP = 2
}
Members of OutputModes :
public enum OutputModes {
// Dual Pin Power
DualPinPower = 1,
// Standard output
StandardOutput = 0
}
Logo

UnderAutomation
66 Avenue des Champs-Elysées
75008 Paris
FRANCE

© 2021 UnderAutomation - UnderAutomation Universal Robots .NET Communication SDK (Software Development Kit) provides the ability to create customized .NET Core, .NET Framework and .NET Standard applications that can communicate with every UR robots. Ready to use examples for Windows, Mac OS and Linux, LabView, Node.js and Python are provided. It uses TCP/IP Dashboard Server and XML-RPC to remote control the robot and the Client Interface to receive and decode data stream.