SyncOutputWithMotion.cpp

 
#include <cassert>
#include "rsi.h"                                    // Import our RapidCode Library. 
#include "HelperFunctionsCpp.h"                        // Import our SampleApp helper functions.
#include <cmath>
#include "SampleApps.h"
 
using namespace RSI::RapidCode;
 
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();
  HelperFunctionsCpp::CheckErrors(controller);
 
  // Setup the controller for the appropriate hardware configuration.
  if (USE_HARDWARE)
  {
    HelperFunctionsCpp::SetupControllerForHardware(controller);
  }
  else
  {
    HelperFunctionsCpp::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);
    HelperFunctionsCpp::CheckErrors(multiAxis);
 
    // populate the multiaxis
    Axis* axis = controller->AxisGet(AXIS_NUMBER);
    HelperFunctionsCpp::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;
}