Motion: Multi-Axis

Multi-Axis Motion sample application.

We have created arrays for start_position, end_position, velocity, accel, decel and jerkPct and used them in function called MoveSCurve which commands motion for both the axis->

Syncpptart commands both motors to start moving at the same time towards their respective end_positions. SyncEnd commands both the motors to end their motion at the same time when moving towards start_positions.

Precondition

This sample code presumes that the user has set the tuning parameters(PID, PIV, etc.) prior to running this program so that the motor can rotate in a stable manner.

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.

 
#include "rsi.h"                // Import our RapidCode Library. 
#include "HelperFunctionsCpp.h"    // Import our SampleApp helper functions. 
#include <conio.h>
#include "SampleApps.h"
 
using namespace RSI::RapidCode;
 
/*This function will print all the results to the screen*/
void PrintResult(Axis* axisX, Axis* axisY)
{
  printf("Motion Done \n AxisX position->  Commanded: %f  \tActual: %f\n",
    axisX->CommandPositionGet(),
    axisX->ActualPositionGet());
 
  printf(" AxisY position->  Commanded: %f  \tActual: %f\n",
    axisY->CommandPositionGet(),
    axisY->ActualPositionGet());
}
 
int MultiaxisMotion::Run()
{
  /* 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 int MOTION_COUNT = 1;
 
  const double USER_UNITS = 1048576;
 
  // Motion parameters
  const double START_POSITION[AXIS_COUNT] = { 0, 0 };
  const double END_POSITION[AXIS_COUNT] = { 1, 2 };
  const double VELOCITY[AXIS_COUNT] = { 1, 2 };
  const double ACCELERATION[AXIS_COUNT] = { 10, 20 };
  const double DECELERATION[AXIS_COUNT] = { 10, 20 };
  const double JERK_PERCENTAGE[AXIS_COUNT] = { 0, 0 };
 
  // 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 */
 
  // Create and initialize RsiController class 
  MotionController* controller = MotionController::CreateFromSoftware();
  HelperFunctionsCpp::CheckErrors(controller);
 
  // Setup the controller for the appropriate hardware configuration.
  if (USE_HARDWARE)
  {
    HelperFunctionsCpp::SetupControllerForHardware(controller);
  }
  else
  {
    HelperFunctionsCpp::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);
    HelperFunctionsCpp::CheckErrors(axisX);
    axisX->UserUnitsSet(USER_UNITS);
    axisX->PositionSet(0);
    axisX->ErrorLimitActionSet(RSIAction::RSIActionNONE);
 
    Axis* axisY = controller->AxisGet(AXIS_Y);
    HelperFunctionsCpp::CheckErrors(axisY);
    axisY->UserUnitsSet(USER_UNITS);
    axisY->PositionSet(0);
    axisY->ErrorLimitActionSet(RSIAction::RSIActionNONE);
 
    // Initialize a MultiAxis, using the last MotionSupervisor.
    MultiAxis* multiAxisXY = controller->MultiAxisGet(controller->MotionCountGet() - 1);
    HelperFunctionsCpp::CheckErrors(multiAxisXY);
    multiAxisXY->AxisAdd(axisX);
    multiAxisXY->AxisAdd(axisY);
 
    // make sure all axes are enabled and ready
    multiAxisXY->Abort();
    multiAxisXY->ClearFaults();
    multiAxisXY->AmpEnableSet(true);
 
    // Set SYNC_START motion attribute mask.
    multiAxisXY->MotionAttributeMaskOnSet(RSIMotionAttrMask::RSIMotionAttrMaskSYNC_START);
    printf("\nMotionStart...");
 
    // Commanding motion using Syncpptart to start motion for both the axis at the same time.
    multiAxisXY->MoveSCurve(END_POSITION, VELOCITY, ACCELERATION, DECELERATION, JERK_PERCENTAGE);
    multiAxisXY->MotionDoneWait();
 
    // Calling function created on top.
    PrintResult(axisX, axisY);
 
    // Set SYNC_END motion attribute mask
    multiAxisXY->MotionAttributeMaskOnSet(RSIMotionAttrMask::RSIMotionAttrMaskSYNC_END);
    printf("\nMotionStart...");
 
    // Commanding motion using SyncEnd to end motion for both the axis at the same time.
    multiAxisXY->MoveSCurve(START_POSITION, VELOCITY, ACCELERATION, DECELERATION, JERK_PERCENTAGE);
    multiAxisXY->MotionDoneWait();
 
    // Calling function created on top
    PrintResult(axisX, axisY);
 
    printf("\nTrapezoidal Motion Done\n");
 
    // Disable the all the axes
    multiAxisXY->AmpEnableSet(false);
  }
  catch (RsiError const& err)
  {
    printf("\n%s\n", err.text);
    return -1;
  }
  controller->Delete();
  return 0;
}