phantom-axis.cpp

Note

See Axis: Configuration 📜 for a detailed explanation of this sample code.

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.

/*  This sample app demonstrates how to create and configure phantom axes
    that can be used for virtual axis operations.
*/
 
#include "helpers.h"          // import our helper functions.
#include "config.h"           // import our configuration.
#include "rsi.h"              // import our RapidCode Library.
 
using namespace RSI::RapidCode; // Import the RapidCode namespace
 
int main()
{
  const std::string SAMPLE_APP_NAME = "📜 Axis: Phantom Axis";
 
  // print a start message to indicate that the sample app has started
  Helpers::PrintHeader(SAMPLE_APP_NAME);
 
  /* CONSTANTS */
  // *NOTICE* The following constants must be configured before attempting to run with hardware.
  const int NUM_AXES = 1;   // the number of axes to configure, default is 0 for this template
  const int AXIS_INDEX = 0; // the index of the axis to configure
 
  /* RAPIDCODE INITIALIZATION */
 
  // create the controller
  MotionController::CreationParameters params = Config::GetCreationParameters();
  MotionController *controller = MotionController::Create(&params);
 
  // set the exit code to an error value.  
  int exitCode = -1;
  try   // Ensure that the controller is deleted if an error occurs.
  {
    // prepare the controller as defined in config.h depending on the configuration
    Helpers::CheckErrors(controller);
    Config::SetupController(controller, NUM_AXES);
 
    /* SET CONTROLLER OBJECT COUNTS HERE*/
    // normally you would set the number of axes here, but for samples that is handled in the Config::SetupController function
    // controller->AxisCountSet(NUM_AXES); 
 
    /* SAMPLE APP BODY */

    // get the axis
    Axis *axis = controller->AxisGet(AXIS_INDEX);
    Helpers::CheckErrors(axis);
 
    // configure the axis as a phantom axis
    // these limits are not meaningful for a Phantom Axis (e.g., a phantom axis has no actual position so a position error trigger is not necessary)
    // therefore, you must set all of their actions to "NONE".
    axis->PositionSet(0);                                      // Set the position to 0
    axis->ErrorLimitActionSet(RSIAction::RSIActionNONE);       // Set Error Limit Action.
    axis->AmpFaultActionSet(RSIAction::RSIActionNONE);         // Set Amp Fault Action.
    axis->AmpFaultTriggerStateSet(1);                          // Set Amp Fault Trigger State.
    axis->HardwareNegLimitActionSet(RSIAction::RSIActionNONE); // Set Hardware Negative Limit Action.
    axis->HardwarePosLimitActionSet(RSIAction::RSIActionNONE); // Set Hardware Positive Limit Action.
    axis->SoftwareNegLimitActionSet(RSIAction::RSIActionNONE); // Set Software Negative Limit Action.
    axis->SoftwarePosLimitActionSet(RSIAction::RSIActionNONE); // Set Software Positive Limit Action.
    axis->HomeActionSet(RSIAction::RSIActionNONE);             // Set Home Action.
 
    // reduce from max slightly, so XML to string serialization and deserialization works without throwing System.OverflowException
    const double positionToleranceMax = std::numeric_limits<double>::max() / 10.0;
    axis->PositionToleranceCoarseSet(positionToleranceMax); // set Settling Coarse Position Tolerance to max value
 
    // set Settling Fine Position Tolerance to max value (so Phantom axis will get immediate MotionDone when target is reached)
    axis->PositionToleranceFineSet(positionToleranceMax);
 
    axis->MotorTypeSet(RSIMotorType::RSIMotorTypePHANTOM); // Set the MotorType to phantom
 
    std::cout << "Phantom Axis created with index: " << AXIS_INDEX << std::endl;
 
    exitCode = 0; // Set the exit code to success.
  }
  catch (const std::exception &ex)
  {
    std::cerr << ex.what() << std::endl;
    exitCode = -1;
  }
  // clean up the controller and any other objects as needed
  Config::Cleanup(controller);
 
  // 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
  Helpers::PrintFooter(SAMPLE_APP_NAME, exitCode);
 
  return exitCode;
}