Multi-Axis Velocity

Table of Contents

• • 🔹 What is Multi-Axis Motion?
  • 🔹 When to Use Multi-Axis Motion?
  • 🔹 Multi-Axis Motion Test
    • Why did we Test?
    • Conclusion
  • 📜 Sample Code

Perform velocity moves on multiple axes that can be updated synchronously and on the fly.

🔹 What is Multi-Axis Motion?

Multi-Axis Velocity Motion refers to a multi-axis velocity move that can be updated on the fly. This means that when a new velocity is commanded, all axes will update their velocities synchronously.

🔹 When to Use Multi-Axis Motion?

When it is necessary to update velocity, synchronously, and on the fly on multiple axes.

🔹 Multi-Axis Motion Test

In this picture, you can observe a Multi-Axis object updating its velocity 5 separate times every second. All 6 axes updated their velocity synchronously and on the fly. This means that every 1 second, the velocity of all 6 axes were updated and their update rate was tightly synchronized (happening at the same time).

In this picture, you can observe 6 axes Multi-Axis object being updated with different velocities every 100ms.

In this picture, you can observe how all 6 axes were updated every 100ms with random velocities, and every velocity update was happening at the same time (The vertical white lines display when a move is being updated).

Why did we Test?

It was important to see how fast we could update velocities on a Multi-Axis object and how synchronized these velocity moves would be.

Therefore, we ran a test that would update a Multi-Axis velocity 100,000 times. We found that every velocity update was happening at approximately 2ms.

Conclusion

A Multi-Axis object velocity can be updated every 2ms.

A Multi-Axis can change all its axes' velocities on the fly in a tightly synchronized manner

📜 Sample Code

• C#

  /*  This sample demonstrates updating a multi-axis velocity synchronously and on the fly.
      It can update velocities at a rate of ~2ms.
      Before running this sample app:
        1. Make sure to configure your Multi-Axis on RapidSetup.
        2. Make sure to adjust your Limits and Action for all axes.
  */
   
  using RSI.RapidCode; // RSI.RapidCode.dotNET;
  using System.Threading;
   
  Console.WriteLine("📜 MultiAxis Motion: Velocity");
   
  // set sample config params
  const int CYCLES = 3;  // how many times to update the velocity
   
  // get rmp objects
  MotionController controller = MotionController.Get();
   
  try
  {
      Helpers.CheckErrors(controller);
   
      // set the motion count to AxisCount + 1, every multiaxis needs a motion supervisor
      var axisCount = controller.AxisCountGet();
      controller.MotionCountSet(axisCount + 1);
   
      // get axes
      Axis axis0 = controller.AxisGet(Constants.AXIS_0_INDEX);
      Helpers.CheckErrors(axis0);
      Axis axis1 = controller.AxisGet(Constants.AXIS_1_INDEX);
      Helpers.CheckErrors(axis1);
      Axis axis2 = controller.AxisGet(Constants.AXIS_2_INDEX);
      Helpers.CheckErrors(axis2);
   
      // get multiaxis (motion supervisor number is equal to number of axes because indexing starts at 0)
      MultiAxis multi = controller.MultiAxisGet(axisCount);
      Helpers.CheckErrors(multi);
   
      // remove any existing axes
      multi.AxisRemoveAll();
   
      // add axes to multiaxis
      multi.AxisAdd(axis0);
      multi.AxisAdd(axis1);
      multi.AxisAdd(axis2);
   
      // prepare for motion
      multi.Abort();
      multi.ClearFaults();
      multi.AmpEnableSet(true);
   
      // define motion parameters
      double[] accelerations = [1000, 1000, 1000];
      double[] velocities = [0, 0, 0];
      Random rnd = new Random();  // for generating random velocities
   
      // update velocities on the fly
      for (int i = 0; i < CYCLES; i++)
      {
          // generate random velocities for all axes
          velocities[0] = rnd.Next(1, 100);
          velocities[1] = rnd.Next(1, 100);
          velocities[2] = rnd.Next(1, 100);
   
          Console.WriteLine($"Cycle {i + 1}: Velocities = [{velocities[0]}, {velocities[1]}, {velocities[2]}]");
   
          // move multiaxis (this will also update the move on the fly)
          multi.MoveVelocity(velocities, accelerations);
   
          // short delay before next iteration
          Thread.Sleep(100);
      }
   
      // clean up
      Helpers.AbortMotionObject(multi);      // stop motion on all axes
      controller.MotionCountSet(axisCount);  // remove multiaxis
  }
  // handle errors as needed
  finally
  {
      controller.Delete();  // dispose
  }