🔹 What is Path Motion?

Path Motion allows complex 3D paths to be specified using simple geometric elements (arcs and lines) in order to define the desired path. Path motion is useful for applications that need to move an end effector in 3D cartesian space on a machine with an arbitrary kinematic model.

🔹 Classes for representing location in 3D space (Pose, Vector, Quaternion)

Class	Composed of	notes
RobotPosition	Pose, RapidVector of Free Axis positions	when a Robot has non-kinematic joints
Pose	Vector3d, Quaternion	Made of a Vector and a Quaternion
Vector3d	X, Y, Z or R, P, Y	3 64-bit floating point double values
Quaternion	W, X, Y, Z	4 64-bit floating point double values
RapidVector	wrapped STL vector	similar to std::vector

🔹 Lines

Lines are defined by an endpoint. The start point will either be the end point of the previously appended motion (For the first move it will be the current position).

Robot.PathLine

🔹 Arcs

Arcs are defined by a rotation direction, endpoint, and center.
Alternatively, the can be defined by an endpoint and radius but must then only take place on a specified plane.

Robot.PathArc

Warning: Currently, all arcs must take place on the XY, YZ, or XZ plane.

🔹 Relative/Absolute

Lines and arcs can be programmed as either relative or absolute.
Absolute moves will be relative to the origin point of your kinematic space. Relative moves will be relative to the start point(end point of previous move)

🔹 Examples of Basic Cartesian Lines and Arcs

CartesianRobot.PathLine(Pose(1000,1000,0));

CartesianRobot.PathArc(RSIRotationDirection.Clockwise,Pose(1000,1000,0), Vector(0,1000,0));

CartesianRobot.PathArcXY(RSIRotationDirection.Clockwise,1000,1000,1000);

Note: This Path Motion feature is not the same as legacy path motion (methods on the MultiAxis class)

📜 Sample Code

Basic Path Motion

C#
// We assume the axes have been confgured and homed properly prior this this program.

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";

// Set the expected labels for each axis.

x_axis.UserLabelSet(xLabel);

y_axis.UserLabelSet(yLabel);

z_axis.UserLabelSet(zLabel);

a_axis.UserLabelSet(aLabel);

b_axis.UserLabelSet(bLabel);

c_axis.UserLabelSet(cLabel);

// 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

// "Z-Axis" has joint index 2

// "A-Axis" has joint index 3

// "B-Axis" has joint index 4

// "C-Axis" has joint index 5

Axis[] axes = new Axis[] { x_axis, y_axis, z_axis, a_axis, b_axis, c_axis };

jointsMultiAxis.AxesAdd(axes, axes.Length);

jointsMultiAxis.ClearFaults();

const LinearUnits units = LinearUnits.Meters;

const string modelName = "RSI_XYZABC_Meters";

const double scaling = 1.0, offset = 0.0;

LinearModelBuilder builder = new LinearModelBuilder(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 a Robot object with a multi axis containing all joints and the kinematic type

robot = Robot.RobotCreate(controller, jointsMultiAxis, builder, MotionController.AxisFrameBufferSizeDefault);

HelperFunctions.CheckErrors(robot);

robot.PathAccelerationSet(1000); // UserUnits per sec sqd

robot.PathVelocitySet(50); // UserUnits per sec

robot.PathProgrammingModeSet(PathMode.Absolute);

robot.PathLine(new Pose(1, 1, 0));

robot.PathArc(new Pose(0, 2, 0), new Vector3d(0, 1, 0), RotationDirection.Clockwise);

jointsMultiAxis.ClearFaults();

jointsMultiAxis.AmpEnableSet(true);

robot.Run(); // Starts the motion. Calling with the false arguement for non blocking behavior

bool isRunning = robot.IsRunning();
C++
/* CONSTANTS */

// *NOTICE* The following constants must be configured before attempting to run with hardware.

// Axis configuration parameters

const int AXIS_COUNT = (2);

const int AXIS_X = 0;

const int AXIS_Y = 1;

const double USER_UNITS = 1048576;

// Default file path for recording the path followed by the axes

const char* const PATH_MOTION_FILEPATH = "PathMotion.csv";

// To run with hardware, set the USE_HARDWARE flag to true AFTER you have configured the parameters above and taken proper safety precautions.

USE_HARDWARE = false;

/* SAMPLE APP BODY */

Axis* axisX;

Axis* axisY;

MultiAxis* multiAxisXY;

double running_x = 0;

double running_y = 0;

double line_A[2] = { running_x, running_y };

running_x += -0.5;

double line_B[2] = { running_x, running_y };

running_y += -0.5;

double line_C[2] = { running_x, running_y };

//curve down

running_y += (-0.25);

double arc_center_A[2] = { running_x,running_y };

running_x += (0.25);

//curve left

running_x += -0.25;

double arc_center_B[2] = { running_x,running_y };

running_y += -0.25;

//curve up

running_y += 0.25;

double arc_center_C[2] = { running_x,running_y };

running_x += -0.25;

//curve right

running_x += 0.25;

double arc_center_D[2] = { running_x,running_y };

running_y += 0.25;

running_x += -0.5;

running_y += 0.5;

double line_D[2] = { running_x, running_y };

// Create and initialize RsiController class

MotionController* controller = MotionController::CreateFromSoftware();

SampleAppsHelper::CheckErrors(controller);

// Setup the controller for the appropriate hardware configuration.

if (USE_HARDWARE)

{

SampleAppsHelper::SetupControllerForHardware(controller);

}

else

{

SampleAppsHelper::SetupControllerForPhantoms(controller, AXIS_COUNT, { AXIS_X, AXIS_Y });

}

try

{

// enable one MotionSupervisor for the MultiAxis

controller->MotionCountSet(controller->AxisCountGet() + 1);

// Get Axis X and Y respectively.

Axis* axisX = controller->AxisGet(AXIS_X);

SampleAppsHelper::CheckErrors(axisX);

axisX->PositionSet(0);

axisX->HomeMethodSet(RSIHomeMethod::RSIHomeMethodCURRENT_POSITION);

axisX->ErrorLimitActionSet(RSIAction::RSIActionNONE);

axisX->AmpDisableActionSet(RSI::RapidCode::RSIMotorDisableAction::RSIMotorDisableActionNONE);

axisX->SoftwareNegLimitActionSet(RSI::RapidCode::RSIAction::RSIActionNONE);

axisX->SoftwarePosLimitActionSet(RSI::RapidCode::RSIAction::RSIActionNONE);

axisX->UserUnitsSet(USER_UNITS);

axisX->Abort();

Axis* axisY = controller->AxisGet(AXIS_Y);

SampleAppsHelper::CheckErrors(axisY);

axisY->PositionSet(0);

axisY->HomeMethodSet(RSIHomeMethod::RSIHomeMethodCURRENT_POSITION);

axisY->ErrorLimitActionSet(RSIAction::RSIActionNONE);

axisY->AmpDisableActionSet(RSI::RapidCode::RSIMotorDisableAction::RSIMotorDisableActionNONE);

axisY->SoftwareNegLimitActionSet(RSI::RapidCode::RSIAction::RSIActionNONE);

axisY->SoftwarePosLimitActionSet(RSI::RapidCode::RSIAction::RSIActionNONE);

axisY->UserUnitsSet(USER_UNITS);

axisY->Abort();

// Initialize a MultiAxis, using the last MotionSupervisor.

MultiAxis* multiAxisXY = controller->MultiAxisGet(controller->MotionCountGet() - 1);

SampleAppsHelper::CheckErrors(multiAxisXY);

multiAxisXY->AxisAdd(axisX);

multiAxisXY->AxisAdd(axisY);

// make sure all axes are enabled and ready

multiAxisXY->Abort();

multiAxisXY->ClearFaults();

multiAxisXY->AmpEnableSet(true);

axisX->Home();

axisY->Home();

multiAxisXY->AmpEnableSet(false);

// set the trajectory info

multiAxisXY->VectorVelocitySet(1.0 * USER_UNITS);

multiAxisXY->VectorAccelerationSet(10.0 * USER_UNITS);

multiAxisXY->VectorDecelerationSet(10.0 * USER_UNITS);

// start path list

double start_positions[2] = { axisX->CommandPositionGet(),axisY->CommandPositionGet() };

multiAxisXY->PathListStart(start_positions);

multiAxisXY->ClearFaults();

// turn on blending (smooth corners)

multiAxisXY->PathBlendSet(true);

// Lines and arcs

multiAxisXY->PathLineAdd(line_A);

multiAxisXY->PathLineAdd(line_B);

multiAxisXY->PathLineAdd(line_C);

multiAxisXY->PathArcAdd(arc_center_A, -90.0);

multiAxisXY->PathArcAdd(arc_center_B, -90.0);

multiAxisXY->PathArcAdd(arc_center_C, -90.0);

multiAxisXY->PathArcAdd(arc_center_D, -90.0);

multiAxisXY->PathLineAdd(line_D);

// end path list

multiAxisXY->PathListEnd();

// make sure all axes are enabled and ready

multiAxisXY->ClearFaults();

multiAxisXY->AmpEnableSet(true);

// execute the motion

multiAxisXY->PathMotionStart();

// log positions

std::ofstream myfile;

myfile.open(PATH_MOTION_FILEPATH);

myfile << "samples,x,y,\n";

while (!multiAxisXY->MotionDoneGet()) {

myfile << controller->SampleCounterGet() << "," << axisX->CommandPositionGet() << "," << axisY->CommandPositionGet() << "\n";

controller->SampleWait(10);

}

// wait for motion to complete

multiAxisXY->MotionDoneWait();

multiAxisXY->AmpEnableSet(false);

myfile.close();

printf("\n%s\n", PATH_MOTION_FILEPATH);

}

catch (RsiError const& err)

{

printf("\n%s\n", err.text);

return -1;

}

controller->Delete(); // Delete the controller as the program exits to ensure memory is deallocated in the correct order.

return 0;

Gantry Prime Axis

Setup model with 1:1 geared axis.

C#
// We assume the axes have been confgured and homed properly prior this this program.

const string xLabel = "X-Axis";

const string yLabel = "Y-Axis";

const string primeLabel = "Y-Prime";

// Set the expected labels for each axis.

x_axis.UserLabelSet(xLabel);

y_axis.UserLabelSet(yLabel);

prime_axis.UserLabelSet(primeLabel);

// 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

Axis[] axes = new Axis[] { x_axis, y_axis, prime_axis };

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 LinearModelBuilder(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 = primeLabel, Scaling = scaling, Offset = offset });

// Create a 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.RobotCreate(controller, jointsMultiAxis, builder, motionFrameBufferSize);

HelperFunctions.CheckErrors(robot);

Changing Linear Units

How changing linear units affects vel and accel setters.

C#
// We assume the axes have been confgured and homed properly prior this this program.

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";

// Set the expected labels for each axis.

x_axis.UserLabelSet(xLabel);

y_axis.UserLabelSet(yLabel);

z_axis.UserLabelSet(zLabel);

a_axis.UserLabelSet(aLabel);

b_axis.UserLabelSet(bLabel);

c_axis.UserLabelSet(cLabel);

// 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

// "Z-Axis" has joint index 2

// "A-Axis" has joint index 3

// "B-Axis" has joint index 4

// "C-Axis" has joint index 5

Axis[] axes = new Axis[] { x_axis, y_axis, z_axis, a_axis, b_axis, c_axis };

jointsMultiAxis.AxesAdd(axes, axes.Length);

const LinearUnits units = LinearUnits.Millimeters;

const string modelName = "RSI_XYZABC_Millimeters";

const double scaling = 1.0, offset = 0.0;

LinearModelBuilder builder = new LinearModelBuilder(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 a Robot object with a multi axis containing all joints and the kinematic type

robot = Robot.RobotCreate(controller, jointsMultiAxis, builder, MotionController.AxisFrameBufferSizeDefault);

HelperFunctions.CheckErrors(robot);

//NOTE: to use the above kinematic model you must have a gantry (linear 1:1 kinematics) and each linear axis must have its user units scaled to millimeters

robot.PathAccelerationSet(10); //Sets the PATH acceleration to 10 Millimeters per second sqd

robot.PathVelocitySet(10); //Sets the PATH velocity to 10 Millimeters per second

Console.WriteLine(robot.PathUnitsGet());//This will print the int value for the enum for Millimeters

robot.PathUnitsSet(LinearUnits.Centimeters);

robot.PathAccelerationSet(10); //Sets the PATH acceleration to 10 Centimeters per second sqd

robot.PathVelocitySet(10); //Sets the PATH velocity to 10 Centimeters per second

Console.WriteLine(robot.PathLinearScalingGet());//Will print the scale factor to convert CM to MM

//NOTE: you can also set this directly. Doing so will result in PathUnitsGet() returning NONE

3D Rendering

Get points in 3D space for rendering them.

C#
const ulong frameCount = 500;

ulong totalFrames = frameCount;

ulong startFrame = 0;

while (totalFrames == frameCount)

{

RapidVectorRobotPosition positions = robot.PathPlannedPositionsGet(startFrame, frameCount);

totalFrames = positions.Size();

foreach (RobotPosition position in positions.ToArray())

{

Pose pose = position.Pose;

Vector3d spatial = pose.Position;

double xCoord = spatial.X, yCoord = spatial.Y, zCoord = spatial.Z;

Quaternion orientation = pose.Orientation;

}

//Add code here to create the rendering out of the positions you have collected.

//Use your prefered 3d library.

//Example:

//vector3 = new Vector3D(xPosition, yPosition, zPosition);

//linePositions.Add(Vector3DToVector3(vector3));

startFrame += totalFrames;

}

Table of Contents