Read and write variables

This article shows how to read the global variables of a Universal Robots cobot from a PC, in C# or Python, and how to change them. A global variable is a program variable or an installation variable of PolyScope. To exchange values with a running program at high speed, use registers instead.

Which way to choose

In the SDK, a variable is a GlobalVariable: its Name, its Type and its Value, with typed conversions (ToInt, ToFloat, ToBool, ToPose, ToList, ToMatrix).

Read with the Primary Interface

The Primary Interface sends the list of the variables and their new values when they change. GlobalVariables keeps the last values received:

• ListUpdated is raised when the list of the variables changes;
• ValuesUpdated is raised when at least one value changes;
• GetAll() and GetByName() return the last values received.

// The Primary Interface is enabled by default
robot.Connect("192.168.0.1");
// Raised when the list of variables changes
robot.PrimaryInterface.GlobalVariables.ListUpdated += (sender, e) =>
{
  GlobalVariable[] variables = e.Variables;
};

// Raised when at least one value changes
robot.PrimaryInterface.GlobalVariables.ValuesUpdated += (sender, e) =>
{
  GlobalVariable[] variables = e.Variables;
};

// Last values received
GlobalVariable[] all = robot.PrimaryInterface.GlobalVariables.GetAll();
GlobalVariable myVar = robot.PrimaryInterface.GlobalVariables.GetByName("myVar");

if (myVar != null)
{
  // Typed value, according to myVar.Type
  switch (myVar.Type)
  {
    case GlobalVariableTypes.Bool: bool b = myVar.ToBool(); break;
    case GlobalVariableTypes.Int: int i = myVar.ToInt(); break;
    case GlobalVariableTypes.Float: float f = myVar.ToFloat(); break;
    case GlobalVariableTypes.String: string s = myVar.ToString(); break;
    case GlobalVariableTypes.Pose: Pose p = myVar.ToPose(); break;
    case GlobalVariableTypes.List: GlobalVariableValue[] l = myVar.ToList(); break;
    case GlobalVariableTypes.Matrix: Array m = myVar.ToMatrix(); break;
  }
}
}
}

The robot sends the variables when they change. If your application connects while a program runs, the list stays empty until a value changes. The decoding depends on the PolyScope version (up to 3.2, up to 5.9, later versions): the SDK selects it, and FirmwareVersion gives it.

Read with the Dashboard Server

GetVariable asks the robot for one variable of the running program. The type is deduced from the value.

// The Dashboard Server is enabled by default
robot.Connect("192.168.0.1");
// Read the variable "myVar" of the running program
var response = robot.Dashboard.GetVariable("myVar");

if (response.Succeed)
{
  GlobalVariable variable = response.Value;

  Console.WriteLine($"{variable.Name} = {variable.Value} ({variable.Type})");

  // Typed conversions, according to variable.Type
  if (variable.Type == GlobalVariableTypes.Pose)
  {
    Pose pose = variable.ToPose();
  }
}
}
}

Write a variable

No interface of the robot writes a variable while a program runs. Two ways remain:

Before the program

Send URScript that sets the variable. The running program stops, so do it when no program runs, for example to initialize an installation variable. To make PolyScope save the new value of an installation variable, also set _hidden_verificationVariable to 0:

robot.Connect("192.168.0.1");
// Set the installation variable i_var_1 to 6.
// The running program stops: send it when no program runs.
// _hidden_verificationVariable = 0 makes PolyScope save the new value
robot.PrimaryInterface.Script.Send(
  "def SetInstallationVariable():\n" +
  "  global _hidden_verificationVariable = 0\n" +
  "  global i_var_1 = 6\n" +
  "end\n");
}
}

A secondary program (sec) does not stop the program, but it cannot write a global variable.

While the program runs

Use the registers: the program reads them with read_input_integer_register, read_input_float_register or read_input_boolean_register, and your application writes them with RTDE up to 500 Hz. See Read and write registers.

Try it in the demo application

Everything on this page can be tried without writing code, in the Running program and variables page of the demo application.

The demo application is open source. The C# source of this page is ProgramControl.cs.

Reference

What to read next

• Read and write registers: exchange values with a running program.
• Send URScript: the forms of URScript and their effect on the program.