HardwareLimits.cpp

 
#include "rsi.h" // Import our RapidCode Library. 
#include "HelperFunctionsCpp.h"                        // Import our SampleApp helper functions.
#include "SampleApps.h"
 
using namespace RSI::RapidCode;
 
int HardwareLimits::Run()
{
  /* CONSTANTS */
  // *NOTICE* The following constants must be configured before attempting to run with hardware.
 
  // Axis configuration parameters
  const int AXIS_COUNT = 1;                         // Specify how many axes we will be using in this sample.
  const int AXIS_NUMBER = 0;                        // Specify which axis/motor we will be controlling.
 
  const double USER_UNITS = 1048576;                // Specify your counts per unit / user units. (the motor used in this example has 1048576 encoder pulses per revolution)
 
  // Hardware Limit configuration parameters
  const bool ACTIVE_HIGH = true;                  // Constant for active high.
  const bool ACTIVE_LOW = false;                  // Constant for active low.
  const double HW_POS_DURATION_TIME = 0.01;       // Positive limit duration. (in seconds)
  const double HW_NEG_DURATION_TIME = 0.01;       // Negative limit duration. (in seconds)
 
  // 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;
 
  // The rmpPath only needs to be set if the project directory is different than the rapid setup directory.
  // *NOTICE* When setting the rmpPath, be sure to uncomment the rmpPath arguement in MotionController::CreateFromSoftware() in the Run() function.
  const std::string rmpPath = "C:\\RSI\\X.X.X\\";            // Insert the path location of the RMP.rta (usually the RapidSetup folder)
 
  /* SAMPLE APP BODY */
  
  // Initialize MotionController class.
  MotionController* controller = MotionController::CreateFromSoftware(/*rmpPath*/);   // NOTICE: Uncomment "rmpPath" if project directory is different than rapid setup directory.
  HelperFunctionsCpp::CheckErrors(controller);                              // [Helper Function] Check that the axis has been initialize correctly. 
 
  // Setup the controller for the appropriate hardware configuration.
  if (USE_HARDWARE)
  {
    HelperFunctionsCpp::SetupControllerForHardware(controller);
  }
  else
  {
    HelperFunctionsCpp::SetupControllerForPhantoms(controller, AXIS_COUNT, { AXIS_NUMBER });
  }
 
  try
  {
    Axis* axis = controller->AxisGet(AXIS_NUMBER);                          // Initialize Axis Class. (Use RapidSetup Tool to see what is your axis number)
    HelperFunctionsCpp::CheckErrors(axis);                      // [Helper Function] Check that the axis has been initialize correctly.
 
    printf("Hardware Limits Example\n");
 
    // Change Hardware POSITIVE (+) Limit characteristicpp.
    axis->HardwarePosLimitActionSet(RSIAction::RSIActionE_STOP);                              // Set the positive limit action to E_STOP.
    printf("\nHardware Positive Limit Action set to %i", axis->HardwarePosLimitActionGet());
 
    axis->HardwarePosLimitTriggerStateSet(ACTIVE_HIGH);                                       // Set the positive limit trigger state to ACTIVE_HIGH.
    printf("\nHardware Positive Limit TriggerState set to %i", axis->HardwarePosLimitTriggerStateGet());
 
    axis->HardwarePosLimitDurationSet(HW_POS_DURATION_TIME);                                  // Set the positive limit duration to 0.01 seconds.
    printf("\nHardware Positive Limit Duration set to %f seconds", axis->HardwarePosLimitDurationGet());
 
    // Change Hardware NEGATIVE (-) Limit charateristicpp.
    axis->HardwareNegLimitActionSet(RSIAction::RSIActionE_STOP);                              // Set the negative limit action to E_STOP.
    printf("\nHardware Negative Limit Action set to %i", axis->HardwareNegLimitActionGet());
 
    axis->HardwareNegLimitTriggerStateSet(ACTIVE_LOW);                                        // Set the negative limit trigger state to ACTIVE_LOW.
    printf("\nHardware Negative Limit TriggerState set to %i", axis->HardwareNegLimitTriggerStateGet());
 
    axis->HardwareNegLimitDurationSet(HW_NEG_DURATION_TIME);                                  // Set the negative limit duration to 0.01 seconds.
    printf("\nHardware Negative Limit Duration set to %f seconds", axis->HardwareNegLimitDurationGet());
 
    printf("\nAll Hardware Limit characteristicpp set\n");
  }
  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;
}