MotionHoldReleasedBySoftwareAddress.cpp

 
#include <thread>
#include "rsi.h"                // Import our RapidCode Library. 
#include "HelperFunctionsCpp.h"    // Import our SampleApp helper functions. 
#include "SampleApps.h"
 
using namespace RSI::RapidCode;
 
int MotionHoldReleasedBySoftwareAddress::Run()
{
  /* CONSTANTS */
  // *NOTICE* The following constants must be configured before attempting to run with hardware.
 
  // Axis configuration parameters
  const int AXIS_COUNT = 1;
  const int AXIS_NUMBER = 0;
 
  const double USER_UNITS = 1048576;
 
  // Index for the address in the user buffer to use for the motion hold
  const int USER_BUFFER_INDEX = 0;
 
  // Motion parameters
  const double MOTION_DISTANCE = 0.25;
 
  const std::chrono::duration HOLD_TIME = std::chrono::milliseconds(2000);
 
  // 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 char 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.
 
    // GET AXIS READY
    axis->UserUnitsSet(USER_UNITS);                     // Specify the counts per Unit.
    axis->PositionSet(0);                               // Make sure motor starts at position 0 every time.
    axis->ErrorLimitTriggerValueSet(1);                 // Set the position error trigger value
    axis->Abort();                                      // If there is any motion happening, abort it.
    axis->ClearFaults();                                // Clear faults.>
    axis->AmpEnableSet(true);                           // Enable the motor.
 
    // GET AN AVAILABLE MEMORY ADDRESS
    uint64_t userBufferAddress = controller->AddressGet(RSIControllerAddressType::RSIControllerAddressTypeUSER_BUFFER, USER_BUFFER_INDEX);
 
    // SET MOTION HOLD ON AVAILABLE SOFTWARE ADDRESS
    axis->MotionHoldTypeSet(RSIMotionHoldType::RSIMotionHoldTypeCUSTOM);        // Use TypeCUSTOM to hold execution based on a particular bit turning ON or OFF.
    axis->MotionHoldUserAddressSet(userBufferAddress);                          // Specify the available hostAddress . This address' value will be used to evaluate the motion hold condition.
    axis->MotionHoldUserMaskSet(0x1);                                           // Specify the bit you want to mask/watch from the MotionHoldUserAddressSet' address value (this evaluates using a logic AND)
    axis->MotionHoldUserPatternSet(0x1);                                        // Specify the bit value that will release the motion hold. (When this value is met, motion hold will be released)
 
    // Check the condition to be false at first
    if (controller->MemoryGet(userBufferAddress) != 0x0)        // Check Available host address value is mask to be false (in this case 0x0)
    {
      controller->MemorySet(userBufferAddress, 0x0);          // if not, mask it to false value/condition (in this case 0x0)
    }
 
    // COMMAND MOTION (NO HOLD YET)
    printf("\nCommanding Motion...\n");
    axis->MoveRelative(MOTION_DISTANCE);                            // Command simple relative motion. (This motion will have no HOLD)
 
    // SET MOTION HOLD
    printf("\nSetting Motion Hold...\n");
    axis->MotionAttributeMaskOnSet(RSIMotionAttrMask::RSIMotionAttrMaskHOLD);       // Set the HOLD motion attribute mask ON. (This initializes the HOLD on a particular motion)
 
    // COMMAND MOTION AGAIN (MOTION WILL BE HELD)
    printf("Commanding Motion...\n");
    axis->MoveRelative(MOTION_DISTANCE);                                                         // Command simple relative motion. (This motion will be HOLD by the condition above)
    std::this_thread::sleep_for(HOLD_TIME);                           // Sleep for 3 second before releasing motion hold.
 
    // RELEASE MOTION HOLD (MOTION WILL START)
    printf("Releasing Motion Hold...\n");
    controller->MemorySet(userBufferAddress, 0x1);      // Release Motion Hold by specifying the host address value to SET Condition (in this case 0x10000)
    axis->MotionDoneWait();                             // Wait for motion to be done
    controller->MemorySet(userBufferAddress, 0x0);      // Specify host address value back to false value/condition (in this case 0x0)
 
    // CLEAR MOTION HOLD
    printf("\nClearing Motion Hold...\n");
    axis->MotionAttributeMaskOffSet(RSIMotionAttrMask::RSIMotionAttrMaskHOLD);      // Set the HOLD motion attribute mask OFF. (This will clear any motion HOLDS that were set on this Axis)
 
    // COMMAND MOTION AGAIN (NO HOLD)
    printf("Commanding Motion...\n");
    axis->MoveRelative(-2 * MOTION_DISTANCE);           // This motion will have no HOLD since the previous line has set the motion attribute mask OFF.
    axis->MotionDoneWait();                             // Wait for Motion to be completed.
 
    // Abort and Clear Faults
    axis->Abort();
    axis->ClearFaults();
  }
  catch (RsiError const& err)
  {
    printf("%s\n", err.text);       // If there are any exceptions/issues this will be printed out.
    return -1;
  }
  controller->Delete();               // Delete the controller as the program exits to ensure memory is deallocated in the correct order.
  return 0;
}