UserLimitDigitalInputAction.cpp

 
#include "rsi.h"                // Import our RapidCode Library. 
#include "HelperFunctionsCpp.h"    // Import our SampleApp helper functions. 
#include "SampleApps.h"
 
using namespace RSI::RapidCode;
 
int UserLimitDigialInputAction::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)
 
  const int IO_NODE_NUMBER = 0; // which SqNode to use for I/O?
  const int USER_LIMIT = 0; // which user limit to use?
  const int CONDITION = 0; // which condition to use (0 or 1)
  const int INPUT_BIT_NUMBER = 0; // which input bit?
 
  // 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 */
 
  // Initialize MotionController class.
  MotionController* controller = MotionController::CreateFromSoftware();
  HelperFunctionsCpp::CheckErrors(controller);
 
  // Setup the controller for the appropriate hardware configuration.
  if (USE_HARDWARE)
  {
    HelperFunctionsCpp::SetupControllerForHardware(controller);
  }
  else
  {
    std::cout << "This sample app cannot be run without hardware." << std::endl;
    return 0;
  }
 
  // RapidCode interface classes
  IO* io;
  IOPoint* digitalInput;
  try
  {
    // Create a new User Limit
    controller->UserLimitCountSet(1);
 
    // initialize the I/O class
    io = controller->IOGet(IO_NODE_NUMBER);
    HelperFunctionsCpp::CheckErrors(io);
 
    digitalInput = IOPoint::CreateDigitalInput(io, INPUT_BIT_NUMBER);
 
    auto addr = digitalInput->AddressGet();
    auto mask1 = digitalInput->MaskGet();
    auto mask2 = digitalInput->MaskGet();
 
    // configure user limit to evaluate input bit
    controller->UserLimitConditionSet(USER_LIMIT,
      CONDITION,
      RSIUserLimitLogic::RSIUserLimitLogicEQ,
      digitalInput->AddressGet(),
      digitalInput->MaskGet(),
      digitalInput->MaskGet());
 
    // enable the user limit, generate ESTOP_ABORT action when input is turned on
    controller->UserLimitConfigSet(USER_LIMIT, RSIUserLimitTriggerType::RSIUserLimitTriggerTypeSINGLE_CONDITION, RSIAction::RSIActionE_STOP_ABORT, AXIS_NUMBER, 0.0);
 
    printf("Waiting for the input bit to go high...\n");
    printf("\nPress Any Key To Exit.\n");
 
    // wait for user limit to trigger
    while (controller->OS->KeyGet((int32_t)RSIWait::RSIWaitPOLL) < 0)
    {
      printf("User Limit state is %d\r", controller->UserLimitStateGet(USER_LIMIT));
      controller->OS->Sleep(1);
    }
 
    // disable User Limit
    controller->UserLimitDisable(USER_LIMIT);
  }
  catch (RsiError const& rsiError)
  {
    printf("Text:  %s\n", rsiError.text);
    return -1;
  }
  controller->Delete(); // Delete the controller as the program exits to ensure memory is deallocated in the correct order.
  return 0;
}