MoveVelocitySCurve()

void MoveVelocitySCurve	(	const double *const	velocity,
		const double *const	accel,
		const double *const	jerkPct )

Description:

MoveVelocitySCurve commands the MultiAxis to a specified target velocity for each Axis.

Parameters

*velocity	Array of target velocities (UserUnits/second).
*accel	Array of average accelerations (UserUnits/second/second). (peak up to 2× accel when jerkPercent = 100, see below)
*jerkPct	0.0 to 100.0 - The percentage of acceleration time which is smoothed.

Warning

Using a non-zero JerkPercent increases the maximum acceleration above the user-specified average. If your system can’t handle the higher peak, you risk overshoot or excessive load. The relation between average acceleration and maximum acceleration is:

\[ Maximum Acceleration \;=\; \frac{accel}{1 - \bigl(jerkPercent \times 0.005\bigr)} \]

• accel: the requested (average) acceleration value given in the MoveSCurve command.
• jerkPercent: the percent of time with non-zero jerk (0–100) given in the MoveSCurve command.
• Maximum Acceleration: the resulting peak commanded acceleration.

See the S-Curve Motion concept page for more information.

Sample Code:

Motion: Multi-Axis

/*  This sample demonstrates updating a multi-axis velocity synchronously and on the fly.
    It can update velocities at a rate of ~2ms.
    Before running this sample app:
      1. Make sure to configure your Multi-Axis on RapidSetup.
      2. Make sure to adjust your Limits and Action for all axes.
*/
 
using RSI.RapidCode; // RSI.RapidCode.dotNET;
using System.Threading;
 
Console.WriteLine("📜 MultiAxis Motion: Velocity");
 
// set sample config params
const int CYCLES = 3;  // how many times to update the velocity
 
// get rmp objects
MotionController controller = MotionController.Get();
 
try
{
    Helpers.CheckErrors(controller);
 
    // set the motion count to AxisCount + 1, every multiaxis needs a motion supervisor
    var axisCount = controller.AxisCountGet();
    controller.MotionCountSet(axisCount + 1);
 
    // get axes
    Axis axis0 = controller.AxisGet(Constants.AXIS_0_INDEX);
    Helpers.CheckErrors(axis0);
    Axis axis1 = controller.AxisGet(Constants.AXIS_1_INDEX);
    Helpers.CheckErrors(axis1);
    Axis axis2 = controller.AxisGet(Constants.AXIS_2_INDEX);
    Helpers.CheckErrors(axis2);
 
    // get multiaxis (motion supervisor number is equal to number of axes because indexing starts at 0)
    MultiAxis multi = controller.MultiAxisGet(axisCount);
    Helpers.CheckErrors(multi);
 
    // remove any existing axes
    multi.AxisRemoveAll();
 
    // add axes to multiaxis
    multi.AxisAdd(axis0);
    multi.AxisAdd(axis1);
    multi.AxisAdd(axis2);
 
    // prepare for motion
    multi.Abort();
    multi.ClearFaults();
    multi.AmpEnableSet(true);
 
    // define motion parameters
    double[] accelerations = [1000, 1000, 1000];
    double[] velocities = [0, 0, 0];
    Random rnd = new Random();  // for generating random velocities
 
    // update velocities on the fly
    for (int i = 0; i < CYCLES; i++)
    {
        // generate random velocities for all axes
        velocities[0] = rnd.Next(1, 100);
        velocities[1] = rnd.Next(1, 100);
        velocities[2] = rnd.Next(1, 100);
 
        Console.WriteLine($"Cycle {i + 1}: Velocities = [{velocities[0]}, {velocities[1]}, {velocities[2]}]");
 
        // move multiaxis (this will also update the move on the fly)
        multi.MoveVelocity(velocities, accelerations);
 
        // short delay before next iteration
        Thread.Sleep(100);
    }
 
    // clean up
    Helpers.AbortMotionObject(multi);      // stop motion on all axes
    controller.MotionCountSet(axisCount);  // remove multiaxis
}
// handle errors as needed
finally
{
    controller.Delete();  // dispose
}

See also

MotionAttributeMaskGet