Motion: Sync Outputs (w/ Element ID)

Sync Output With Motion sample application.

Synchronize setting outputs with motion element ID's.

Precondition

This sample code presumes that the user has set the tuning paramters(PID, PIV, etc.) prior to running this program so that the motor can rotate in a stable manner.

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.

 
#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;
}