6.5 RT Tutorials

The Real-Time Tutorials section introduces the Doosan Robot API’s real-time control (RT) and monitoring features. This mode allows users to stream joint or task-space commands and receive real-time data through a dedicated UDP-based communication channel.

These examples demonstrate how to establish an RT connection, configure the transmission parameters, start and stop RT control, and process real-time feedback data.

Tutorial Flow

  1. RT Connection Setup: Establish the real-time control link.

  2. RT Output Configuration: Define the control frequency.

  3. Start / Stop RT Control: Enable and disable real-time command streaming.

  4. RT Data Monitoring: Retrieve and log real-time output data (position, velocity, torque).

  5. Speed / Acceleration Limits (Extension): Set the limits applied to real-time commands.

  6. Unified Safety Handling: Combine RT loop with safety stop and disconnection recovery.

RT Connection Setup

Purpose
Establish a dedicated UDP communication channel for real-time data exchange between the robot controller and an external PC.

// Connect using default IP and port
Drfl.connect_rt_control();

// Alternatively, specify a custom host and port
// Drfl.connect_rt_control("192.168.137.100", 12348);

Check
The connection establishes successfully without timeout, and the controller responds with RT connection acknowledgment.

RT Output Configuration

Purpose
Define the update period for RT communication.

std::string version = "v1.0";
float period = 0.001f;   // 1 ms update period
int loss_count = 4;      // reserved, not used

Drfl.set_rt_control_output(version, period, loss_count);

Check
The robot accepts the configuration and prepares for RT command streaming.

Start / Stop RT Control

Purpose
Start and stop the real-time control loop for command transmission.

// Start streaming
Drfl.start_rt_control();

// Stop streaming after use
Drfl.stop_rt_control();

// End the real-time session
Drfl.disconnect_rt_control();

Check
RT control starts successfully, and robot transitions into real-time operation mode. disconnect_rt_control() ends the real-time session and returns the controller to normal operation.

RT Data Monitoring

Purpose
Access and log real-time joint position, velocity, and torque data.

void OnRTMonitoringData(LPRT_OUTPUT_DATA_LIST tData) {
    static int count = 0;
    if (++count % 500 == 0) {
        printf("timestamp: %.3f\\n", tData->time_stamp);
        printf("q = %.4f %.4f %.4f %.4f %.4f %.4f\\n",
            tData->actual_joint_position[0], tData->actual_joint_position[1],
            tData->actual_joint_position[2], tData->actual_joint_position[3],
            tData->actual_joint_position[4], tData->actual_joint_position[5]);
        printf("q_dot = %.4f %.4f %.4f %.4f %.4f %.4f\\n",
            tData->actual_joint_velocity[0], tData->actual_joint_velocity[1],
            tData->actual_joint_velocity[2], tData->actual_joint_velocity[3],
            tData->actual_joint_velocity[4], tData->actual_joint_velocity[5]);
    }
}

// Callback registration
Drfl.set_on_rt_monitoring_data(OnRTMonitoringData);

Check
RT callback outputs continuous joint position, velocity, and torque data at 1 ms intervals.

Speed / Acceleration Limits (Extension)

Purpose
Set the joint and Cartesian velocity and acceleration limits that apply to real-time commands.

float vel[6] = {0.2, 0.0, 0.0, 0.0, 0.0, 0.0};
float acc[6] = {0.5, 0.5, 0.5, 0.5, 0.5, 0.5};

// Set joint velocity and acceleration in real-time
Drfl.set_velj_rt(vel);
Drfl.set_accj_rt(acc);

// Optional: Cartesian space velocity control
Drfl.set_velx_rt(0.2f, 0.2f);
Drfl.set_accx_rt(0.5f, 0.5f);

Check
The limits apply to every subsequent real-time command.

Unified Safety Handling

Purpose
Integrate RT control with safety stop and reconnection logic for stable long-term operation.

void OnDisconnected() {
    printf("[RT] Disconnected from controller. Retrying...\\n");
    while (!Drfl.open_connection("192.168.137.100")) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
}

void OnMonitoringStateCB(const ROBOT_STATE eState) {
    if (eState == STATE_SAFE_STOP || eState == STATE_SAFE_OFF) {
        Drfl.stop_rt_control();
        Drfl.SetRobotControl(CONTROL_SERVO_ON);
        Drfl.start_rt_control();
    }
}

Check
open_connection() restores the controller connection after a drop. Re-establishing the real-time session requires restarting the application.

Note

  • Real-time control requires stable network conditions and a controller version that supports UDP-based RT API.

  • Always verify connection using 6.2 Basic Tutorials and recovery logic from 6.3 Advanced Tutorials before running RT mode.