Data streaming

Data described below are sent by the robot controller at 10Hz by the TCP/IP Client 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; }

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
public ControlModes ControlMode { get; set; },
// The button Emergency Stop is pressed
public bool EmergencyStopped { get; set; },
// Robot is connected to its controller
public bool PhysicalRobotConnected { get; set; },
// The running program is paused
public bool ProgramPaused { get; set; },
// A program is running
public bool ProgramRunning { get; set; },
// A stop occured due to a fault detection.
public bool ProtectiveStopped { get; set; },
// Real robot mode active. False if robot is in simulation
public bool RealRobotEnabled { get; set; },
// 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.
public bool RobotPowerOn { get; set; },
// Speed scaling
public double SpeedScaling { get; set; },
// Overriden speed ratio between 0 (0%) and 1 (100%)
public double TargetSpeedFraction { get; set; },
// Maximum target speed fraction
public double TargetSpeedFractionLimit { get; set; },
// Timespan since the robot controller as 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
public JointData Base { get; set; },
// Elbow joint data
public JointData Elbow { get; set; },
// Shoulder joint data
public JointData Shoulder { get; set; },
// Wrist1 joint data
public JointData Wrist1 { get; set; },
// Wrist2 joint data
public JointData Wrist2 { get; set; },
// 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
public double ActualSpeed { get; set; },
// Motor current in Amps
public float Current { get; set; },
// Joint mode
public JointModes JointMode { get; set; },
// Angular joint position in radians
public double Position { get; set; },
// Angular target position in radians
public double TargetPosition { get; set; },
// Joint temperature in °C
public float Temperature { get; set; },
// Motor votage in Volts
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])
public double AnalogInput2 { get; set; },
// Value of Analog input 3 (analog_in[3])
public double AnalogInput3 { get; set; },
// Unit of analog input 2 (analog_in[2])
public AnalogRanges AnalogInputRange2 { get; set; },
// Unit of analog input 3 (analog_in[3])
public AnalogRanges AnalogInputRange3 { get; set; },
// Tool current in Amps
public float ToolCurrent { get; set; },
// Tool mode
public ToolModes ToolMode { get; set; },
// Tool output voltage
public sbyte ToolOutputVoltage { get; set; },
// Tool Temperature in °C
public float ToolTemperature { get; set; },
// Actual robot voltage power supply
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])
public double AnalogInput0 { get; set; },
// Value of analog input 1 (analog_in[1])
public double AnalogInput1 { get; set; },
// Unit of analog input 0 (analog_in[0])
public AnalogRanges AnalogInputRange0 { get; set; },
// Unit of analog input 1 (analog_in[1])
public AnalogRanges AnalogInputRange1 { get; set; },
// Value of analog output 0 (analog_out[0])
public double AnalogOutput0 { get; set; },
// Value of analog output 1 (analog_out[1])
public double AnalogOutput1 { get; set; },
// Unit of analog output 0 (analog_out[0])
public AnalogRanges AnalogOutputDomain0 { get; set; },
// Unit of analog output 1 (analog_out[1)
public AnalogRanges AnalogOutputDomain1 { get; set; },
// Register where each bit is a digital input value
public MasterboardDigitalIO DigitalInputs { get; set; },
// Register where each bit is a digital output value
public MasterboardDigitalIO DigitalOutputs { get; set; },
// The robot is interfaced to injection molding machines Euromap 67
public sbyte Euromap67Installed { get; set; },
// Euromap current
public float EuromapCurrent { get; set; },
// Register where each bit is a digital Euromap input
public int EuromapInputBits { get; set; },
// Register where each bit is a digital Euromap output
public int EuromapOutputBits { get; set; },
// Euromap votage
public float EuromapVoltage { get; set; },
// Robot is in reduced speed mode
public byte InReducedMode { get; set; },
// Temperature of masterboard in °C
public float MasterboardTemperature { get; set; },
// Current of all digital and analog inputs and outputs
public float MasterIOCurrent { get; set; },
// Position of operational mode selector input switch
public byte OperationalModeSelectorInput { get; set; },
// Robot current consumption in Amps
public float RobotCurrent { get; set; },
// Voltage of internal 48V power supply
public float RobotVoltage48V { get; set; },
// Masterboard safety mode
public SafetyStatus Safetymode { get; set; },
// 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
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
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 degrees of the TCP in the current frame
public double Rx { get; set; },
// RY axis coordinate in degrees of the TCP in the current frame
public double Ry { get; set; },
// RZ axis coordinate in degrees of the TCP in the current frame
public double Rz { get; set; },
// RX position of the TCP in the flange frame
public double TCPOffsetRX { get; set; },
// RY position of the TCP in the flange frame
public double TCPOffsetRY { get; set; },
// RZ position of the TCP in the flange frame
public double TCPOffsetRZ { get; set; },
// X position of the TCP in the flange frame
public double TCPOffsetX { get; set; },
// Y position of the TCP in the flange frame
public double TCPOffsetY { get; set; },
// Z position of the TCP in the flange frame
public double TCPOffsetZ { get; set; },
// X axis coordinate in mm of the TCP in the current frame
public double X { get; set; },
// Y axis coordinate in mm of the TCP in the current frame
public double Y { get; set; },
// Z axis coordinate in mm of the TCP in the current frame
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
public JointKinematicsInfo Base { get; set; },
// Calibration status (0 : OK)
public int CalibrationStatus { get; set; },
// Elbow kinematics info
public JointKinematicsInfo Elbow { get; set; },
// Shoulder kinematics info
public JointKinematicsInfo Shoulder { get; set; },
// Wrist1 kinematics info
public JointKinematicsInfo Wrist1 { get; set; },
// Wrist2 kinematics info
public JointKinematicsInfo Wrist2 { get; set; },
// Wrist3 (Tool) kinematics info
public JointKinematicsInfo Wrist3 { get; set; }
}
![](/universal-robots/joints.png)Members of JointKinematicsInfo :
public class JointKinematicsInfo {
// Joint checksum
public int Checksum { get; set; },
// DH convention a parameter
public double DHa { get; set; },
// DH convention alpha parameter
public double Dhalpha { get; set; },
// DH convention d parameter
public double DHd { get; set; },
// DH convention theta parameter
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²
public double AJointDefault { get; set; },
// Default TCP acceleration speed in mm/s²
public double AToolDefault { get; set; },
// Base joint configuration
public JointConfiguration Base { get; set; },
// Controller box type
public ControllerBoxTypes ControllerBoxType { get; set; },
// Elbow joint configuration
public JointConfiguration Elbow { get; set; },
// Equipment radius in m
public double EqRadius { get; set; },
// Masterboard version
public int MasterboardVersion { get; set; },
// Robot serie
public RobotSubTypes RobotSubType { get; set; },
// Model of the robot (UR3, UR5, UR10, UR16)
public RobotModels RobotType { get; set; },
// Shoulder joint configuration
public JointConfiguration Shoulder { get; set; },
// Default joint angular speed in rad/s
public double VJointDefault { get; set; },
// Default TCP speed speed in mm/s
public double VToolDefault { get; set; },
// Wrist1 joint configuration
public JointConfiguration Wrist1 { get; set; },
// Wrist2 joint configuration
public JointConfiguration Wrist2 { get; set; },
// 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
public double DHa { get; set; },
// Alpha parameter of Denavit–Hartenberg (DH) convention
public double DHalpha { get; set; },
// d parameter of Denavit–Hartenberg (DH) convention
public double DHd { get; set; },
// Theta parameter of Denavit–Hartenberg (DH) convention
public double DHtheta { get; set; },
// Maximum rotation speed in rad/s²
public double JointMaxAcceleration { get; set; },
// Maximum angular position in rad
public double JointMaxLimit { get; set; },
// Maximum rotation speed in rad/s
public double JointMaxSpeed { get; set; },
// Minimum angular position in rad
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
public bool FreedriveButtonEnabled { get; set; },
// The free drive button is pressed
public bool FreedriveButtonPressed { get; set; },
// 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
public double Frx { get; set; },
// Fry calibration data
public double Fry { get; set; },
// Frz calibration data
public double Frz { get; set; },
// Fx calibration data
public double Fx { get; set; },
// Fy calibration data
public double Fy { get; set; },
// 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
public int BaudRate { get; set; },
// Parity
public int Parity { get; set; },
// RX Idle Chars
public float RxIdleChars { get; set; },
// Stop bits
public int StopBits { get; set; },
// Is the tool communication interface enabled
public bool ToolCommunicationIsEnabled { get; set; },
// 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
public DigitalOutputConfigurations DigitalOutputMode0 { get; set; },
// Digital output 1 configuration
public DigitalOutputConfigurations DigitalOutputMode1 { get; set; },
// 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) bietet die Möglichkeit, angepasste .NET Core, .NET Framework und .NET Standard Anwendungen zu erstellen, die mit jedem UR-Roboter kommunizieren können. Es werden gebrauchsfertige Beispiele für Windows, Mac OS und Linux, LabView, Node.js und Python bereitgestellt. Es verwendet TCP/IP Dashboard Server und XML-RPC zur Fernsteuerung des Roboters und die Client-Schnittstelle zum Empfang und zur Dekodierung des Datenstroms.