Script command interface

The Script Command Interface allows sending predefined commands to the robot while there is URScript running that is connected to it.

An example to utilize the script command interface can be found in the freedrive_example.cpp.

In order to use the ScriptCommandInterface, there has to be a script code running on the robot that connects to the ScriptCommandInterface. This happens as part of the big external_control.urscript. In order to reuse that with this example, we will create a full UrDriver and leverage the ScriptCommandInterface through this.

At first, we create a ExampleRobotWrapper object in order to initialize communication with the robot.

Listing 47 examples/script_command_interface.cpp

  g_my_robot =
      std::make_unique<ExampleRobotWrapper>(robot_ip, OUTPUT_RECIPE, INPUT_RECIPE, g_HEADLESS, "external_control.urp");

  // Check if the robot version supports the friction scales command (requires 5.25.1 / 10.12.1)
  auto version = g_my_robot->getUrDriver()->getVersion();
  g_support_set_friction_scales = (version.major == 5 && version >= urcl::VersionInformation::fromString("5.25.1")) ||
                                  (version.major >= 10 && version >= urcl::VersionInformation::fromString("10.12.1"));
  if (!g_support_set_friction_scales)
  {
    URCL_LOG_INFO("Setting friction scales is not supported on this robot (version %s). "
                  "Requires at least 5.25.1 / 10.12.1. Skipping friction scale commands.",
                  version.toString().c_str());
  }

  if (!g_my_robot->isHealthy())
  {
    URCL_LOG_ERROR("Something in the robot initialization went wrong. Exiting. Please check the output above.");
    return 1;
  }

  // We will send script commands from a separate thread. That will stay active as long as
  // g_running is true.
  g_running = true;
  std::thread script_command_send_thread(sendScriptCommands);

The script commands will be sent in a separate thread which will be explained later.

Since the connection to the script command interface runs as part of the bigger external_control script, we’ll wrap the calls alongside a full ExampleRobotWrapper. Hence, we’ll have to send keepalive signals regularly to keep the script running:

Listing 48 examples/script_command_interface.cpp

  std::chrono::duration<double> time_done(0);
  std::chrono::duration<double> timeout(second_to_run);
  auto stopwatch_last = std::chrono::steady_clock::now();
  auto stopwatch_now = stopwatch_last;
  while ((time_done < timeout || second_to_run.count() == 0) && g_my_robot->isHealthy())
  {
    g_my_robot->getUrDriver()->writeKeepalive();

    stopwatch_now = std::chrono::steady_clock::now();
    time_done += stopwatch_now - stopwatch_last;
    stopwatch_last = stopwatch_now;
    std::this_thread::sleep_for(
        std::chrono::milliseconds(static_cast<int>(1.0 / g_my_robot->getUrDriver()->getControlFrequency())));
  }

  URCL_LOG_INFO("Timeout reached.");
  g_my_robot->getUrDriver()->stopControl();

Sending script commands

Once the script is running on the robot, a connection to the driver’s script command interface should be established. The UrDriver forwards most calls of the ScriptCommandInterface and we will use that interface in this example. To send a script command, we can e.g. use g_my_robot->getUrDriver()->zeroFTSensor().

In the example, we have wrapped the calls into a lambda function that will wait a specific timeout, print a log output what command will be sent and then call the respective command:

Listing 49 examples/script_command_interface.cpp

    run_cmd("Setting tool voltage to 24V",
            []() { g_my_robot->getUrDriver()->setToolVoltage(urcl::ToolVoltage::_24V); });
    run_cmd("Enabling tool contact mode", []() { g_my_robot->getUrDriver()->startToolContact(); });

    if (g_support_set_friction_scales)
    {
      // setFrictionScales is only supported from PolyScope 5.25.1 / PolyScope X 10.12.1 and upwards.
      run_cmd("Turn off friction_compensation by setting the friction scales to zeroes",
              []() { g_my_robot->getUrDriver()->setFrictionScales({ 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }); });
    }
    run_cmd("Setting tool voltage to 0V", []() { g_my_robot->getUrDriver()->setToolVoltage(urcl::ToolVoltage::OFF); });
    run_cmd("Zeroing the force torque sensor", []() { g_my_robot->getUrDriver()->zeroFTSensor(); });
    run_cmd("Disabling tool contact mode", []() { g_my_robot->getUrDriver()->endToolContact(); });
    run_cmd("Setting TCP offset to [0.0, 0.0, 0.10, 0.0, 0.0, 0.0]",
            []() { g_my_robot->getUrDriver()->setTcpOffset({ 0.0, 0.0, 0.10, 0.0, 0.0, 0.0 }); });
    run_cmd("Setting payload to 2.0kg with custom inertia and 0.5s transition time", []() {
      g_my_robot->getUrDriver()->setTargetPayload(2.0, { 0.0, 0.0, 0.1 }, { 0.003, 0.003, 0.003, 0.0, 0.0, 0.0 }, 0.5);
    });

    if (g_support_set_friction_scales)
    {
      // setFrictionScales is only supported from PolyScope 5.25.1 / PolyScope X 10.12.1 and upwards.
      run_cmd("Turn on friction_compensation by setting the friction scales to non-zero values", []() {
        g_my_robot->getUrDriver()->setFrictionScales({ 0.9, 0.9, 0.8, 0.9, 0.9, 0.9 },
                                                     { 0.8, 0.8, 0.7, 0.8, 0.8, 0.8 });
      });
    }
  }

The lambda itself looks like this:

Listing 50 examples/script_command_interface.cpp

  auto run_cmd = [](const std::string& log_output, std::function<void()> func) {
    const std::chrono::seconds timeout(3);
    if (g_running)
    {
      // We wait a fixed time so that not each command is run directly behind each other.
      // This is done for example purposes only, so users can follow the effect on the teach
      // pendant.
      std::this_thread::sleep_for(timeout);
      URCL_LOG_INFO(log_output.c_str());
      func();
    }
  };

For a list of all available script commands, please refer to the ScriptCommandInterface class here.