Motion: Path

Learn how to work with Path motion in C#.

Warning

This is a sample program to assist in the integration of the RMP motion controller with your application. It may not contain all of the logic and safety features that your application requires. We recommend that you wire an external hardware emergency stop (e-stop) button for safety when using our code sample apps. Doing so will help ensure the safety of you and those around you and will prevent potential injury or damage.

The sample apps assume that the system (network, axes, I/O) are configured prior to running the code featured in the sample app. See the Configuration page for more information.

In this page:

• 📜 Motion: Path
• 📜 Motion: Path Gantry
• 📜 Motion: Path 3D Rendering

📜 Motion: Path

Learn how to set up and run Path Motion 📖 with a Robot object. Shows how to create kinematic models, program path movements using lines and arcs, and execute coordinated multi-axis motion.

/*  This sample demonstrates how to set up and run path motion with a Robot object.
    Shows how to create kinematic models, program path movements using lines and arcs,
    and execute coordinated multi-axis motion.
*/
 
using RSI.RapidCode; // RSI.RapidCode.dotNET;
using System.Threading;
 
Console.WriteLine("📜 Motion: Path");
 
// get rmp objects
MotionController controller = MotionController.Get();
 
try
{
    Helpers.CheckErrors(controller);

    // set robot axis labels
    const string xLabel = "X-Axis";
    const string yLabel = "Y-Axis";
    const string zLabel = "Z-Axis";
    const string aLabel = "A-Axis";
    const string bLabel = "B-Axis";
    const string cLabel = "C-Axis";
 
    // get the 6 axis needed for XYZABC robot
    Axis xAxis = controller.AxisGet(Constants.AXIS_0_INDEX);
    Helpers.CheckErrors(xAxis);
    Axis yAxis = controller.AxisGet(Constants.AXIS_1_INDEX);
    Helpers.CheckErrors(yAxis);
    Axis zAxis = controller.AxisGet(Constants.AXIS_2_INDEX);
    Helpers.CheckErrors(zAxis);
    Axis aAxis = controller.AxisGet(Constants.AXIS_3_INDEX);
    Helpers.CheckErrors(aAxis);
    Axis bAxis = controller.AxisGet(Constants.AXIS_4_INDEX);
    Helpers.CheckErrors(bAxis);
    Axis cAxis = controller.AxisGet(Constants.AXIS_5_INDEX);
    Helpers.CheckErrors(cAxis);
 
    // configure phantom axes
    Helpers.PhantomAxisReset(xAxis);
    Helpers.PhantomAxisReset(yAxis);
    Helpers.PhantomAxisReset(zAxis);
    Helpers.PhantomAxisReset(aAxis);
    Helpers.PhantomAxisReset(bAxis);
    Helpers.PhantomAxisReset(cAxis);
 
    // set axis labels
    xAxis.UserLabelSet(xLabel);
    yAxis.UserLabelSet(yLabel);
    zAxis.UserLabelSet(zLabel);
    aAxis.UserLabelSet(aLabel);
    bAxis.UserLabelSet(bLabel);
    cAxis.UserLabelSet(cLabel);
 
    // create multi-axis object for joints
    MultiAxis jointsMultiAxis = controller.MultiAxisGet(0);
    Axis[] axes = [ xAxis, yAxis, zAxis, aAxis, bAxis, cAxis ];
    jointsMultiAxis.AxesAdd(axes, axes.Length);
    jointsMultiAxis.ClearFaults();
 
    // create kinematic model with 6-axis configuration
    const LinearUnits units = LinearUnits.Meters;
    const string modelName = "RSI_XYZABC_Meters";
    const double scaling = 1.0; 
    const double offset = 0.0;
 
    LinearModelBuilder builder = new(modelName);
    builder.UnitsSet(units);
    builder.JointAdd(new LinearJointMapping(0, CartesianAxis.X)     { ExpectedLabel = xLabel, Scaling = scaling, Offset = offset });
    builder.JointAdd(new LinearJointMapping(1, CartesianAxis.Y)     { ExpectedLabel = yLabel, Scaling = scaling, Offset = offset });
    builder.JointAdd(new LinearJointMapping(2, CartesianAxis.Z)     { ExpectedLabel = zLabel, Scaling = scaling, Offset = offset });
    builder.JointAdd(new LinearJointMapping(3, CartesianAxis.Roll)  { ExpectedLabel = aLabel, Scaling = scaling, Offset = offset });
    builder.JointAdd(new LinearJointMapping(4, CartesianAxis.Pitch) { ExpectedLabel = bLabel, Scaling = scaling, Offset = offset });
    builder.JointAdd(new LinearJointMapping(5, CartesianAxis.Yaw)   { ExpectedLabel = cLabel, Scaling = scaling, Offset = offset });
 
    // create Robot object with multi axis and kinematic model
    Robot robot = Robot.RobotCreate(controller, jointsMultiAxis, builder, MotionController.AxisFrameBufferSizeDefault);
    Helpers.CheckErrors(robot);
 
    // print some robot info
    Console.WriteLine($"Robot model: {robot.ModelGet().NameGet()}");
    Console.WriteLine($"Robot units: {robot.ModelGet().UnitsGet()}");
 
    // set path motion parameters
    robot.PathAccelerationSet(1000);  // user units per sec squared
    robot.PathVelocitySet(50);        // user units per sec
 
    // program path motion
    robot.PathProgrammingModeSet(PathMode.Absolute);
    robot.PathLine(target: new Pose(1, 1, 1));
    robot.PathArc(
        target: new Pose(0, 2, 1),
        center: new Vector3d(0, 1, 1),
        direction: RotationDirection.Clockwise);
 
    // enable amplifiers
    jointsMultiAxis.AmpEnableSet(true);
 
    // start path motion (non-blocking)
    robot.Run();
 
    // monitor motion
    while (robot.IsRunning())
    {
        Thread.Sleep(100);
        Console.WriteLine("Path motion executing...");
    }
 
    // cleanup
    Robot.RobotDelete(controller, robot);
}
// handle errors as needed
finally
{
    controller.Delete();  // dispose
}

📜 Motion: Path Gantry

Learn how to set up a kinematic model with a gantry prime axis for Path Motion 📖 . Shows how to configure a 1:1 geared axis system where two physical axes work together.

/*  This sample demonstrates how to set up a kinematic model with a gantry prime axis.
    Shows how to configure a 1:1 geared axis system where two physical axes work together
    to control the same cartesian coordinate.
*/
 
using RSI.RapidCode; // RSI.RapidCode.dotNET;
 
Console.WriteLine("📜 Motion: Path Gantry");
 
// get rmp objects
MotionController controller = MotionController.Get();
 
try
{
    Helpers.CheckErrors(controller);

    // set robot axis labels
    const string xLabel = "X-Axis";
    const string yLabel = "Y-Axis";
    const string yPrimeLabel = "Y-Prime";
 
    // get the 3 axis needed for XY_Yp robot
    Axis xAxis = controller.AxisGet(Constants.AXIS_0_INDEX);
    Helpers.CheckErrors(xAxis);
    Axis yAxis = controller.AxisGet(Constants.AXIS_1_INDEX);
    Helpers.CheckErrors(yAxis);
    Axis primeAxis = controller.AxisGet(Constants.AXIS_2_INDEX);
    Helpers.CheckErrors(primeAxis);
 
    // configure phantom axes
    Helpers.PhantomAxisReset(xAxis);
    Helpers.PhantomAxisReset(yAxis);
    Helpers.PhantomAxisReset(primeAxis);
 
    // set the expected labels for each axis
    xAxis.UserLabelSet(xLabel);
    yAxis.UserLabelSet(yLabel);
    primeAxis.UserLabelSet(yPrimeLabel);
 
    // the joint index of each axis is the index within the MultiAxis object
    // "X-Axis" has joint index 0
    // "Y-Axis" has joint index 1
    // "Y-Prime" has joint index 2
    MultiAxis jointsMultiAxis = controller.MultiAxisGet(0);
    Axis[] axes = [xAxis, yAxis, primeAxis];
    jointsMultiAxis.AxesAdd(axes, axes.Length);
 
    const LinearUnits units = LinearUnits.Millimeters;
    const string modelName = "RSI_XY_Yp";
    const double scaling = 1.0, offset = 0.0;
    LinearModelBuilder builder = new(modelName);
    builder.UnitsSet(units);
    builder.JointAdd(new LinearJointMapping(0, CartesianAxis.X) { ExpectedLabel = xLabel,     Scaling = scaling, Offset = offset });
    builder.JointAdd(new LinearJointMapping(1, CartesianAxis.Y) { ExpectedLabel = yLabel,     Scaling = scaling, Offset = offset });
    builder.JointAdd(new LinearJointMapping(2, CartesianAxis.Y) { ExpectedLabel = yPrimeLabel, Scaling = scaling, Offset = offset });
 
    // create Robot object where the y and y prime will be geared 1:1
    const int motionFrameBufferSize = 50; // this is the minimum valid motion frame buffer size
    Robot robot = Robot.RobotCreate(controller, jointsMultiAxis, builder, motionFrameBufferSize);
    Helpers.CheckErrors(robot);
 
    Console.WriteLine($"Model name: {robot.ModelGet().NameGet()}");
    Console.WriteLine($"Model units: {robot.ModelGet().UnitsGet()}");
    Console.WriteLine("Gantry configuration: Y-axis and Y-Prime axis are geared 1:1");
 
    // cleanup
    Robot.RobotDelete(controller, robot);
}
// handle errors as needed
finally
{
    controller.Delete();  // dispose
}

📜 Motion: Path 3D Rendering

Learn how to get 3D path points for rendering visualization from Path Motion 📖 . Shows how to retrieve planned positions for use with 3D graphics libraries.

/*  This sample demonstrates how to get 3D path points for rendering visualization.
    Shows how to retrieve planned positions from a Robot path for use with 3D graphics libraries
    or visualization tools.
*/
 
using RSI.RapidCode; // RSI.RapidCode.dotNET;
 
Console.WriteLine("📜 Motion: Path 3D Rendering");
 
// get rmp objects
MotionController controller = MotionController.Get();
 
try
{
    Helpers.CheckErrors(controller);

    // set robot axis labels
    const string xLabel = "X-Axis";
    const string yLabel = "Y-Axis";
    const string zLabel = "Z-Axis";
 
    // get the 3 axis needed for XYZ robot
    Axis xAxis = controller.AxisGet(Constants.AXIS_0_INDEX);
    Helpers.CheckErrors(xAxis);
    Axis yAxis = controller.AxisGet(Constants.AXIS_1_INDEX);
    Helpers.CheckErrors(yAxis);
    Axis zAxis = controller.AxisGet(Constants.AXIS_2_INDEX);
    Helpers.CheckErrors(zAxis);
 
    // configure phantom axes
    Helpers.PhantomAxisReset(xAxis);
    Helpers.PhantomAxisReset(yAxis);
    Helpers.PhantomAxisReset(zAxis);
 
    // set axis labels
    xAxis.UserLabelSet(xLabel);
    yAxis.UserLabelSet(yLabel);
    zAxis.UserLabelSet(zLabel);
 
    // create multi-axis object for joints
    MultiAxis jointsMultiAxis = controller.MultiAxisGet(0);
    Axis[] axes = [xAxis, yAxis, zAxis];
    jointsMultiAxis.AxesAdd(axes, axes.Length);
 
    // create simple 3-axis kinematic model
    const string modelName = "RSI_XYZ";
    const double scaling = 1.0;
    const double offset = 0.0;
    
    LinearModelBuilder builder = new(modelName);
    builder.UnitsSet(LinearUnits.Millimeters);
    builder.JointAdd(new LinearJointMapping(0, CartesianAxis.X) { ExpectedLabel = xLabel, Scaling = scaling, Offset = offset });
    builder.JointAdd(new LinearJointMapping(1, CartesianAxis.Y) { ExpectedLabel = yLabel, Scaling = scaling, Offset = offset });
    builder.JointAdd(new LinearJointMapping(2, CartesianAxis.Z) { ExpectedLabel = zLabel, Scaling = scaling, Offset = offset });
 
    // create Robot object
    Robot robot = Robot.RobotCreate(controller, jointsMultiAxis, builder, MotionController.AxisFrameBufferSizeDefault);
    Helpers.CheckErrors(robot);
 
    // set path motion parameters
    robot.PathAccelerationSet(100);
    robot.PathVelocitySet(50);
    
    // program path motion
    robot.PathProgrammingModeSet(PathMode.Absolute);
    robot.PathLine(target: new Pose(1, 1, 1));
    robot.PathArc(
        target: new Pose(0, 2, 1),
        center: new Vector3d(0, 1, 1),
        direction: RotationDirection.Clockwise);
    
    // process the path to build trajectory
    robot.PathProcessLoadedMoves();
    
    // get path points for 3D rendering
    Console.WriteLine("Retrieving 3D path points for rendering:");
    const ulong frameCount = 500;
    ulong startFrame = 0;
    int totalPointCount = 0;
 
    ulong retrievedFrames;
    do
    {
        RapidVectorRobotPosition positions = robot.PathPlannedPositionsGet(startFrame, frameCount);
        retrievedFrames = positions.Size();
 
        foreach (RobotPosition position in positions.ToArray())
        {
            Vector3d spatial = position.Pose.Position;
 
            // print first 4 points as example
            if (totalPointCount < 4)
            {
                Console.WriteLine($"Point {totalPointCount}: X={spatial.X:F2}, Y={spatial.Y:F2}, Z={spatial.Z:F2}");
            }
 
            totalPointCount++;
 
            // add code here to create rendering with your preferred 3D library
            // examples:
            // vector3 = new Vector3D(spatial.X, spatial.Y, spatial.Z);
            // linePositions.Add(vector3);
            // scene.AddPoint(spatial.X, spatial.Y, spatial.Z);
        }
 
        startFrame += retrievedFrames;
    }
    while (retrievedFrames == frameCount);
 
    // print total points retrieved
    Console.WriteLine($"Total 3D points retrieved: {totalPointCount}");
 
    // cleanup
    Robot.RobotDelete(controller, robot);
}
// handle errors as needed
finally
{
    controller.Delete();  // dispose
}