PointToPoint.cpp

 
#include <cmath>
 
#include "SampleAppsHelper.h" // Import our helper functions.
#include "rsi.h"              // Import our RapidCode Library.
 
using namespace RSI::RapidCode; // Import the RapidCode namespace
 
// Helper function to wait for the axis to reach velocity when performing a velocity move or move with final velocity
static void HelperAtVelocityWait(MotionController *controller, Axis *axis, const int timeout)
{
  // The number of samples to wait before checking if the axis is at velocity
  const int WAIT_SAMPLES = 100;
 
  int samplesWaited = 0;
  while (axis->StatusBitGet(RSIEventType::RSIEventTypeMOTION_AT_VELOCITY) == 0)
  {
    controller->SampleWait(WAIT_SAMPLES);
    samplesWaited += WAIT_SAMPLES;
    if (samplesWaited > timeout)
    {
      throw std::runtime_error("Timeout waiting for motion to reach velocity");
    }
  }
}
 
int main()
{
  const std::string SAMPLE_APP_NAME = "Motion: Point-to-Point";
 
  // Print a start message to indicate that the sample app has started
  SampleAppsHelper::PrintHeader(SAMPLE_APP_NAME);
 
  // *NOTICE* The following constants must be configured before attempting to run with hardware.
  // Motion Parameters
  const double POSITION_0 = 0;       
  const double POSITION_1 = 0.5;     
  const double VELOCITY = 1;         
  const double ACCELERATION = 10;    
  const double DECELERATION = 10;    
  const double JERK_PERCENT = 50;    
  const double FINAL_VELOCITY = 0.5; 
 
  /* RAPIDCODE INITIALIZATION */
 
  // Create the controller
  MotionController::CreationParameters params = SampleAppsHelper::GetCreationParameters();
  MotionController *controller = MotionController::Create(&params);
 
  int exitCode = -1; // Set the exit code to an error value.
  try                // Ensure that the controller is deleted if an error occurs.
  {
    SampleAppsHelper::CheckErrors(controller);
 
    // Prepare the controller and axes as defined in SampleAppsHelper.h
    SampleAppsHelper::SetupController(controller);
 
    /* SAMPLE APP BODY */
 
    /* Configure the controller object counts */
    controller->MotionCountSet(SampleAppsConfig::AXIS_COUNT + 1);
 
    // Get the axes
    Axis *axis = controller->AxisGet(SampleAppsConfig::AXIS_X_INDEX);
    SampleAppsHelper::CheckErrors(axis);
 
    // Specify a timeout for waiting for the motion to complete
    const int32_t TIMEOUT = 10000;
 
    // Clear faults and enable the motor
    axis->ClearFaults();
    axis->AmpEnableSet(true);
 
    /* Absolute (Trapezoidal) Motion */
    std::cout << "Absolute (Trapezoidal) Motion:" << std::endl;
    std::cout << "Moving to position: " << POSITION_1 << std::endl;
    axis->MoveTrapezoidal(POSITION_1, VELOCITY, ACCELERATION, DECELERATION);
    axis->MotionDoneWait(TIMEOUT);
    std::cout << "Motion Complete" << std::endl;
 
    std::cout << "Moving back to position: " << POSITION_0 << std::endl;
    axis->MoveTrapezoidal(POSITION_0, VELOCITY, ACCELERATION, DECELERATION);
    axis->MotionDoneWait(TIMEOUT);
    std::cout << "Motion Complete\n" << std::endl;
 
    /* Relative Motion */
    std::cout << "Relative Motion:" << std::endl;
    std::cout << "Moving to position: " << POSITION_1 << std::endl;
    axis->MoveRelative(POSITION_1 - POSITION_0, VELOCITY, ACCELERATION, DECELERATION, JERK_PERCENT);
    axis->MotionDoneWait(TIMEOUT);
    std::cout << "Motion Complete" << std::endl;
 
    std::cout << "Moving back to position: " << POSITION_0 << std::endl;
    axis->MoveRelative(POSITION_0 - POSITION_1, VELOCITY, ACCELERATION, DECELERATION, JERK_PERCENT);
    axis->MotionDoneWait(TIMEOUT);
    std::cout << "Motion Complete\n" << std::endl;
 
    /* SCurve Motion */
    std::cout << "SCurve Motion:" << std::endl;
    std::cout << "Moving to position: " << POSITION_1 << std::endl;
    axis->MoveSCurve(POSITION_1);
    axis->MotionDoneWait(TIMEOUT);
    std::cout << "Motion Complete" << std::endl;
 
    std::cout << "Moving back to position: " << POSITION_0 << std::endl;
    axis->MoveSCurve(POSITION_0);
    axis->MotionDoneWait(TIMEOUT);
    std::cout << "Motion Complete\n" << std::endl;
 
    /* SCurve Motion with Final Velocity */
    std::cout << "SCurve Motion with Final Velocity:" << std::endl;
    std::cout << "Moving to position: " << POSITION_1 << std::endl;
    std::cout << "Final Velocity: " << FINAL_VELOCITY << std::endl;
    axis->MoveSCurve(POSITION_1, VELOCITY, ACCELERATION, DECELERATION, JERK_PERCENT, FINAL_VELOCITY);
    HelperAtVelocityWait(controller, axis, TIMEOUT);
    std::cout << "Motion Complete" << std::endl;
 
    std::cout << "Moving back to position: " << POSITION_0 << std::endl;
    std::cout << "Final Velocity: " << 0 << std::endl;
    axis->MoveSCurve(POSITION_0, VELOCITY, ACCELERATION, DECELERATION, JERK_PERCENT, 0);
    axis->MotionDoneWait(TIMEOUT);
    std::cout << "Motion Complete\n" << std::endl;
 
    /* Velocity Move */
    std::cout << "Velocity Move:" << std::endl;
    std::cout << "Accelerating to velocity: " << VELOCITY << std::endl;
    axis->MoveVelocity(VELOCITY, ACCELERATION);
    HelperAtVelocityWait(controller, axis, TIMEOUT);
    std::cout << "Motion Complete" << std::endl;
 
    std::cout << "Decelerating to velocity: " << 0 << std::endl;
    axis->MoveVelocity(0, DECELERATION);
    HelperAtVelocityWait(controller, axis, TIMEOUT);
    std::cout << "Motion Complete" << std::endl;
 
    // Return to the original position
    axis->MoveTrapezoidal(POSITION_0, VELOCITY, ACCELERATION, DECELERATION);
    axis->MotionDoneWait(TIMEOUT);
 
    // Disable the motor
    axis->AmpEnableSet(false);
 
    exitCode = 0; // Set the exit code to success.
  }
  catch (const std::exception &ex)
  {
    std::cerr << ex.what() << std::endl;
    exitCode = -1;
  }
  // Delete the controller as the program exits to ensure memory is deallocated in the correct order
  controller->Delete();
 
  // Print a message to indicate the sample app has finished and if it was successful or not
  SampleAppsHelper::PrintFooter(SAMPLE_APP_NAME, exitCode);
 
  return exitCode;
}