Streaming Motion Sync Outputs

Table of Contents

• • 🔹 What are Streaming Motion Sync Outputs?
  • 🔹 Why use Streaming Motion Sync Outputs?
    • Example 1
  • 🔹 Sync Outputs Methods
    • StreamingOutputsEnableSet
    • StreamingOutputAdd
    • StreamingOutputsClear
  • 🔹 Selecting the Right Element ID
  • 🔹 Important: Clearing Outputs Between MovePT/MovePVT Calls
    • Recommended Pattern
  • 🔹 Sync Outputs FAQ
  • 📜 Sample Code
    • Sync Outputs
    • Sync Outputs using Element ID

Utilize Streaming Motion Sync Outputs to precisely synchronize digital outputs with specific motion points during streaming movements, such as PT, PVT, or PVAJT, enhancing coordination and control in automated processes.

🔹 What are Streaming Motion Sync Outputs?

Streaming motion Sync Outputs allow you to change the state of a digital output(s) at a precise moment in Axis or MultiAxis streaming motion (PT, PVT, or PVAJT).

🔹 Why use Streaming Motion Sync Outputs?

Streaming motion Sync Outputs make it easy to change any Digital Output state based on a specified point index (or ElementID), commonly used where precise coordination of motion and Digital Output states are required. For example, triggering a strobe at precise positions.

Example 1

If I make a MovePT() call that contains 5 different motion points. By using StreamingOutputAdd() I can set a specified digital output true/high during the 4th motion point.

Therefore, if our motion points look like:

	1st	2nd	3rd	4th	5th	← motion points
Position[5] =	{1,	2,	4,	10,	14}	← in user counts
Times[5] =	{1,	1,	1,	2,	2}	← in seconds

When it gets to position 10 (or the 4th motion point) the specified output will change its state.

Note

A motion point in Move*PT*() refers to a point that contains Position and Time. If there are 5 motion points, then there are 5 positions with 5 times.

Motion points are zero-indexed. Therefore, if you wish to add a sync output on the 1st motion point you should refer to it as "ElementID 0". Moreover, if you wish to add a sync output on the 2nd motion point you should refer to it as "ElementID 1".

🔹 Sync Outputs Methods

StreamingOutputsEnableSet

Enables or disables streaming outputs for upcoming MovePT/MovePVT calls.

You must call this method before each MovePT/MovePVT call:

• true - Enables streaming outputs. You must add at least one output with StreamingOutputAdd before calling MovePT/MovePVT, or you will get an invalid motion attribute error.
• false - Disables streaming outputs and clears the output list internally.

StreamingOutputAdd

Adds a streaming output to fire at a specific motion point index.

This method applies bitmasks to a controller memory address (or sets an IOPoint state) when the motion reaches the specified point index (ElementID).

Note

You must call StreamingOutputsEnableSet with true before adding outputs.

StreamingOutputsClear

Clears the streaming output list.

Call this method after each MovePT/MovePVT call returns to prepare for the next call. You can safely call this as soon as the move method returns.

🔹 Selecting the Right Element ID

For most Streaming Motion, you can use ElementID to determine where you are within a point set. ElementID 5 = Point 5. Element ID will match the point you provided. Streaming Motion using RSIMotionTypeBESSEL, RSIMotionTypeBSPLINE, and RSIMotionTypeBSPLINE2 involved carrying forward 1 point (Bessel, Bspline2) or 2 points (Bspline). It needs to do this for motion calculations.

Consider a Bspline streaming 100 points per chunk. Two would be carried forward each call. 98 would be associated with the first motion ID. 100 for each of the middle ones. 102 would be associated will the final group. For any middle or final chunk, if you wanted output to happen on the Nth element that you provided, you would add 1 (Bessel and Bspline2) or 2 (Bspline only) respectively to the Output Index. If you wanted an Output to take place on the 99th (Bspline only) or 100th logical user points, you would save it for the next chunk and put it at point 0 or 1.

🔹 Important: Clearing Outputs Between MovePT/MovePVT Calls

Streaming outputs accumulate in an internal list across MovePT/MovePVT calls. They are NOT automatically consumed or cleared when MovePT/MovePVT returns. This means if you add an output for one MovePT/MovePVT call and don't clear it, that output record remains in the list and can interfere with subsequent MovePT/MovePVT calls.

Recommended Pattern

For each MovePT/MovePVT call in streaming motion:

• C#

  // Before MovePT - set enable based on whether this call has outputs
  if (callHasOutputs)
  {
      axis.StreamingOutputsEnableSet(true);
      axis.StreamingOutputAdd(onMask, offMask, address, pointIndex);
      // Add more outputs as needed...
  }
  else
  {
      axis.StreamingOutputsEnableSet(false);
  }
   
  // Execute the motion
  axis.MovePT(type, positions, times, pointCount, emptyCount, retain, final);
   
  // After MovePT - always clear for the next call
  axis.StreamingOutputsClear();

Note

Failing to call StreamingOutputsClear() between MovePT/MovePVT calls can cause outputs from a previous call to interfere with outputs in the current call, potentially causing outputs to be skipped or fired at incorrect times.

🔹 Sync Outputs FAQ

1. What happens when I call StreamingOutputsEnableSet(true)?

When you call StreamingOutputEnableSet(true), all motion sync outputs that you add will get added to the frames which are created by MovePT (only MovePTs that have been called after calling StreamingOutputEnableSet(true)). It does not interfere with motions that have already been queued, loaded, or running.

After you call your move method (MovePT(), etc.), the StreamingOutputs will be copied inside the library and then automatically streamed/buffered to the RMP as frames with motion. You are allowed to clear or disable StreamingOutputs as soon as the move method returns.

📜 Sample Code

Sync Outputs

• C#

      const int TOTAL_POINTS = 4;                 // total number of points
      const int EMPTY_CT = 2;                    // number of points that remains in buffer before e-stop
      const int OUTPUT_INDEX = 0;                 // digital output index that will be controlled
      const int NODE_INDEX = 0;                   // the EtherCAT Node index
   
      double[] positions = [1.0, 2.0, 3.0, 4.0];  // streaming motion positions
      double[] times = [0.5, 0.8, 1, 0.5];      // streaming motion times
      int outputEnableID = 2;                     // motion element ID at which to set output HIGH
      int outputDisableID = 3;                    // motion element ID at which to set output LOW
   
      // create IOPoint for digital output
      IOPoint output0 = IOPoint.CreateDigitalOutput(controller.NetworkNodeGet(NODE_INDEX), OUTPUT_INDEX);
      output0.Set(false);  // set output low initially
   
      // enable streaming/sync outputs
      axis.StreamingOutputsEnableSet(true);
   
      // configure sync outputs - turn output HIGH at motion element 2, LOW at motion element 3
      axis.StreamingOutputAdd(output0, true, outputEnableID);    // turn output HIGH at element ID 2
      axis.StreamingOutputAdd(output0, false, outputDisableID);  // turn output LOW at element ID 3
   
      Console.WriteLine($"Starting streaming motion with {TOTAL_POINTS} points");
      Console.WriteLine($"Output will go HIGH at element ID {outputEnableID}");
      Console.WriteLine($"Output will go LOW at element ID {outputDisableID}");
   
      axis.AmpEnableSet(true, Constants.AMP_ENABLE_MS);
   
      // start streaming motion
      axis.MovePT(RSIMotionType.RSIMotionTypePT, positions, times, TOTAL_POINTS, EMPTY_CT, false, true);
   
      // monitor motion and output state
      while (!axis.MotionDoneGet())
      {
          int currentElement = axis.MotionElementIdExecutingGet();
          bool outputState = output0.Get();
          Console.WriteLine($"Motion Element: {currentElement}, Output State: {outputState}");
   
          Thread.Sleep(50);  // small delay to avoid overwhelming console
      }

• C++

    /* 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 you have.
    const int AXIS_NUMBER = 0;                      // Specify which axis/motor to control.
   
    const double USER_UNITS = 1048576;                 // Specify your counts per unit / user units.   (the motor used in this sample app has 1048576 encoder pulses per revolution)       
   
    // IO configuration parameters
    const int NODE_INDEX = 0;                       // Specify which EtherCat Node will be used
    const int OUTPUT_INDEX = 0;
   
    const int OUTPUT_ENABLE_ID = 2;                         // The motion element ID at which to set the output
    const int OUTPUT_DISABLE_ID = 3;                        // The motion element ID at which to set the output
   
    // Motion parameters
    const int TOTAL_POINTS = 4;                     // total number of points
    const int EMPTY_CT = -1;                        // Number of points that remains in the buffer before an e-stop
    const double POSITIONS[] = { 0.25, 0.50, 0.75, 1.0 };    // These will be the streaming motion 5 positions.
    const double TIMES[] = { 0.5, 1.0, 1.5, 2.0 };        // These will be the streaming motion 5 positions' time. 
   
    // 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.
    char rmpPath[] = "C:\\RSI\\X.X.X\\";            // Insert the path location of the RMP.rta (usually the RapidSetup folder)
   
    // Initialize MotionController class.
    MotionController* controller = MotionController::CreateFromSoftware(/*rmpPath*/);   // NOTICE: Uncomment "rmpPath" if project directory is different than rapid setup directory.
    SampleAppsHelper::CheckErrors(controller);                              // [Helper Function] Check that the axis has been initialize correctly. 
   
    // Setup the controller for the appropriate hardware configuration.
    if (USE_HARDWARE)
    {
      SampleAppsHelper::SetupControllerForHardware(controller);
    }
    else
    {
      SampleAppsHelper::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)
      SampleAppsHelper::CheckErrors(axis);                      // [Helper Function] Check that the axis has been initialize correctly.
   
      axis->PositionSet(0);                                                   // Make sure motor starts at position 0 everytime.
      axis->UserUnitsSet(USER_UNITS);                                         // Change your user units.
      axis->ErrorLimitActionSet(RSIAction::RSIActionNONE);                    // Set Error Limit Action.
      axis->Abort();                                                          // If there is any motion happening, abort it.
      axis->ClearFaults();                                                    // Clear faults.>
      axis->AmpEnableSet(true);                                               // Enable the motor.
   
      // Set up the inputs
      // Ensure the digital out is set low.
      //IOPoint *output0 = IOPoint::CreateDigitalOutput(axis, RSIMotorGeneralIo.RSIMotorGeneralIo16);      // Retrieve DOUT 1, Method 1: requires you know the io adress in memory, slightly faster
      IOPoint* output0 = IOPoint::CreateDigitalOutput(controller->IOGet(NODE_INDEX), OUTPUT_INDEX);        // Retrieve DOUT 1  Method 2: only need to know node index
      output0->Set(false);
   
      // Set up Sync Outputs
      axis->StreamingOutputsEnableSet(true);                                                               // Enable streaming output.
   
      // ENABLE the Sync Output(s)
      axis->StreamingOutputAdd(output0, true, OUTPUT_ENABLE_ID);                                             // This will turn DOUT1 High when the streaming motion reaches its 3rd motion point.
      axis->StreamingOutputAdd(output0, false, OUTPUT_DISABLE_ID);                                           // This will turn DOUT1 Low when the streaming motion reaches its 4th motion point.
   
      // DISABLE the Sync Output(s)
      //axis->StreamingOutputAdd(output0, false, outPutEnableID);
   
      axis->MovePT(RSIMotionType::RSIMotionTypePT, POSITIONS, TIMES, TOTAL_POINTS, EMPTY_CT, false, true);  // Start Streaming Motion
      printf("Motion started. Waiting to complete.\n");
   
      axis->MotionDoneWait();                                                                              // What for Streaming Motion to be done.
      printf("Motion Complete. The outputs should have been set\n");
   
      axis->StreamingOutputsEnableSet(false);                                                              // Disable Sync Outputs.
      axis->AmpEnableSet(false);                                                                           // Disable the motor.
   
    }
    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;

Sync Outputs using Element ID

• C++

    /* 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;