SyncOutputWithMotion.cpp

Attention

See the following Concept pages for a detailed explanation of this sample: Streaming Motion Sync Outputs.

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.

 
#include <cassert>
#include "rsi.h"                                    // Import our RapidCode Library. 
#include "SampleAppsHelper.h"                        // Import our SampleApp helper functions.
#include <cmath>
#include "SampleApps.h"
 
using namespace RSI::RapidCode;                     // Import the RapidCode namespace

int SyncOutputWithMotion::Run()
{
  /* CONSTANTS */
  // *NOTICE* The following constants must be configured before attempting to run with hardware.
 
  // Axis configuration parameters
  const int AXIS_COUNT = 1;                                   // number of axes
  const int AXIS_NUMBER = 0;                                  // axis number
 
  const double USER_UNITS = 1048576;                          // encoder counts per rev (set as appropiate)
 
  // Motion parameters
  const double TIME_SLICE = 0.01;                             // 0.01s = 10ms
  const int REVS = 2;                                         // number of revolutions
  const int RPS = 1;                                          // revs / sec
  const int TOTAL_POINTS = (int)(REVS / TIME_SLICE / RPS);    // total number of points
  const int EMPTY_CT = -1;                                    // Number of points that remains in the buffer before an e-stop
 
  // 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 */
 
  // Initizalize the controller from software w/ multiple axes
  MotionController* controller = MotionController::CreateFromSoftware();
  SampleAppsHelper::CheckErrors(controller);
 
  // Setup the controller for the appropriate hardware configuration.
  if (USE_HARDWARE)
  {
    SampleAppsHelper::SetupControllerForHardware(controller);
  }
  else
  {
    SampleAppsHelper::SetupControllerForPhantoms(controller, AXIS_COUNT, { AXIS_NUMBER });
  }
 
  MultiAxis* multiAxis;
 
  try {
    // add an additional axis for the multiaxis supervisor
    controller->MotionCountSet(controller->AxisCountGet() + 1);
 
    // create the multiaxis using the ID of the first free axis (0 indexed)
    multiAxis = controller->MultiAxisGet(controller->MotionCountGet() - 1);
    SampleAppsHelper::CheckErrors(multiAxis);
 
    // populate the multiaxis
    Axis* axis = controller->AxisGet(AXIS_NUMBER);
    SampleAppsHelper::CheckErrors(axis);
    axis->UserUnitsSet(USER_UNITS);
    axis->ErrorLimitActionSet(RSIAction::RSIActionNONE);
    axis->EStopAbort();
    axis->ClearFaults();
    axis->PositionSet(0);
 
    multiAxis->AxisAdd(axis);
 
    // populate the positions and times 
    std::vector<double> positions, times;
    for (int i = 0; i < TOTAL_POINTS; i += AXIS_COUNT)
    {
      positions.push_back(i * TIME_SLICE * RPS);
      times.push_back(TIME_SLICE);
    }
 
 
    // prepare the controller (and drive)
    multiAxis->Abort();
    multiAxis->ClearFaults();
    assert(multiAxis->StateGet() == RSIState::RSIStateIDLE);
    multiAxis->AmpEnableSet(true);
 
 
    // set up the inputs
    IOPoint* output0 = IOPoint::CreateDigitalOutput(multiAxis->AxisGet(AXIS_NUMBER), RSIMotorGeneralIo::RSIMotorGeneralIo16);
    // ensure the digital out is set low
    output0->Set(0);
 
    // The motion element ID at which to set the output
    int outPutEnableID = TOTAL_POINTS / 2;
 
 
    // enable streaming output
    multiAxis->StreamingOutputsEnableSet(true);
 
 
    // Enable the streaming output (The following are functionally equivalent)
    //multiAxis->StreamingOutputAdd(output0->MaskGet(), 0, output0->AddressGet(), outPutEnableID);
    multiAxis->StreamingOutputAdd(output0, true, outPutEnableID);
 
    // Disable the output (The following are functionally equivalent)
    //multiAxis->StreamingOutputAdd(0, output0->MaskGet(), output0->AddressGet(), outPutEnableID);
    //multiAxis->StreamingOutputAdd(output0, false, outPutEnableID);
 
 
    multiAxis->MovePT(RSIMotionType::RSIMotionTypePT, &positions[0], &times[0], TOTAL_POINTS, EMPTY_CT, false, true);
 
    printf("Motion started. Waiting to complete.\n");
    multiAxis->MotionDoneWait();
    printf("Motion Complete. The outputs should have been set\n");
 
    multiAxis->StreamingOutputsClear();  // cleanup for next run
 
    multiAxis->EStopAbort();
  }
  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;
}