AxisConfiguration.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
 
int main()
{
  // Print a start message to indicate that the sample app has started
  const std::string SAMPLE_APP_NAME = "Axis Configuration";
  SampleAppsHelper::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 = SampleAppsHelper::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 SampleAppsHelper.h depending on the configuration
    SampleAppsHelper::CheckErrors(controller);
    SampleAppsHelper::SetupController(controller, NUM_AXES);
 
    /* SAMPLE APP BODY */
 
    /* SET CONTROLLER OBJECT COUNTS HERE*/
    // Normally you would set the number of axes here, but for samples that is handled in the SampleAppsHelper::SetupController function
    // controller->AxisCountSet(NUM_AXES); 
 
    // Get the axes
    Axis *axis = controller->AxisGet(AXIS_INDEX);
    SampleAppsHelper::CheckErrors(axis);
 
    /* Amp Fault Configuration */
    std::cout << "Configuring Amp Fault parameters\n" << std::endl;
 
    // Parameters
    const double AMP_FAULT_DURATION_TIME = 1;                     // How long the axis must be in the trigger state to be considered an amp fault.
    const RSIAction AMP_FAULT_ACTION = RSIAction::RSIActionABORT; // The action to take when an amp fault occurs.
    const int AMP_FAULT_TRIGGER_STATE = 1;                        // The state that triggers the amp fault, active high = 1, active low = 0.
 
    // SET
    axis->AmpEnableSet(false); // Disable the axis
    axis->AmpFaultDurationSet(AMP_FAULT_DURATION_TIME);
    axis->AmpFaultActionSet(AMP_FAULT_ACTION);
    axis->AmpFaultTriggerStateSet(AMP_FAULT_TRIGGER_STATE);
 
    // GET
    double durationTime = axis->AmpFaultDurationGet();
    RSIAction action = axis->AmpFaultActionGet();
    int triggerState = axis->AmpFaultTriggerStateGet();
 
    std::cout << "Axis Amp Fault parameters have been set" << std::endl;
 
    /* Hardware Limits Configuration */
    std::cout << "Configuring Hardware Limits parameters\n" << std::endl;
 
    // Parameters
    const int TRIGGER_STATE = 1;                        // The state that triggers the positive software limit, active high = 1, active low = 0.
    const double DURATION = 0.01;                       // How long the hardware limit must be in the trigger state to be considered triggered.
    const RSIAction ACTION = RSIAction::RSIActionABORT; // The action to take when the positive hardware limit is triggered.
 
    // SET
    axis->HardwarePosLimitTriggerStateSet(TRIGGER_STATE);
    axis->HardwarePosLimitDurationSet(DURATION);
    axis->HardwarePosLimitActionSet(ACTION);
 
    axis->HardwareNegLimitTriggerStateSet(TRIGGER_STATE);
    axis->HardwareNegLimitDurationSet(DURATION);
    axis->HardwareNegLimitActionSet(ACTION);
 
    // GET
    int posTriggerState = axis->HardwarePosLimitTriggerStateGet();
    double posDuration = axis->HardwarePosLimitDurationGet();
    RSIAction posAction = axis->HardwarePosLimitActionGet();
 
    int negTriggerState = axis->HardwareNegLimitTriggerStateGet();
    double negDuration = axis->HardwareNegLimitDurationGet();
    RSIAction negAction = axis->HardwareNegLimitActionGet();
 
    std::cout << "Axis Hardware Limits have been set" << std::endl;
 
    /* Settling Configuration */
    std::cout << "Configuring Settling parameters\n" << std::endl;
 
    // Parameters
    const double POSITION_TOLERANCE_FINE = 200;   // Tolerance for when a move is considered complete.
    const double POSITION_TOLERANCE_COARSE = 300; // Tolerance for when a move is considered "near" complete.
    const double VELOCITY_TOLERANCE = 12000;      // Tolerance for when a velocity move is considered complete.
    const double SETTLING_TIME = 5;               // How long the axis must be within tolerance to be considered settled.
 
    // SET
    axis->PositionToleranceFineSet(POSITION_TOLERANCE_FINE);
    axis->PositionToleranceCoarseSet(POSITION_TOLERANCE_COARSE);
    axis->VelocityToleranceSet(VELOCITY_TOLERANCE);
    axis->SettlingTimeSet(SETTLING_TIME);
 
    // GET
    double posTolFine = axis->PositionToleranceFineGet();
    double posTolCoarse = axis->PositionToleranceCoarseGet();
    double velTol = axis->VelocityToleranceGet();
    double setTime = axis->SettlingTimeGet();
 
    std::cout << "Axis Settling parameters have been set" << std::endl;
 
    /* Stop Rate Configuration */
    std::cout << "Configuring Stop Rate parameters\n" << std::endl;
 
    // Parameters
    const double STOP_RATE_DEFAULT = 1.0;        // Specify the default STOP rate in seconds.
    const double ESTOP_RATE_DEFAULT = 0.05;      // Specify the default ESTOP rate in seconds.
    const double ESTOP_DECELERATION_RATE = 1000; // Specify the default ESTOP deceleration rate in seconds.
 
    // SET
    axis->StopTimeSet(STOP_RATE_DEFAULT);
    axis->EStopTimeSet(ESTOP_RATE_DEFAULT);
    axis->EStopDecelerationSet(ESTOP_DECELERATION_RATE);
 
    // GET
    double stopRate = axis->StopTimeGet();
    double eStopRate = axis->EStopTimeGet();
    double eStopDeceleration = axis->EStopDecelerationGet();
 
    std::cout << "Axis Stop Rate parameters have been set" << std::endl;
 
    /* User Units Configuration */
    std::cout << "Configuring User Units parameters\n" << std::endl;
 
    // Parameters
    const int ENCODER_RESOLUTION_BITS = 20;                         // The number of bits defining the encoder resolution
    const double USER_UNITS = std::pow(2, ENCODER_RESOLUTION_BITS); // The number of user units per revolution
                                                                    // (2^20 = 1,048,576 user units per revolution)
 
    // SET
    axis->UserUnitsSet(USER_UNITS);
 
    // GET
    double userUnits = axis->UserUnitsGet();
 
    std::cout << "Axis User Units have been set" << 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
  SampleAppsHelper::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
  SampleAppsHelper::PrintFooter(SAMPLE_APP_NAME, exitCode);
 
  return exitCode;
}