28+ years of motion control expertise
Build real-time motion control applications on Windows or Linux with our PC-based controller in C++, C#, Python, GCode, and gRPC.
Architecture
Keep your HMI, vision, and application logic on the host PC while RMP handles deterministic EtherCAT motion control on a real-time core.
Runs all motion and IO algorithms plus the EtherCAT master stack on an isolated real-time core.
RMP owns one dedicated real-time core. Your application runs on all other cores and talks to RMP over shared memory via RapidCode.
A single PC runs your entire machine: motion control, HMI, vision, and logging.
Up to 128 synchronized motors and 10,000+ I/O points across a single EtherCAT line.
SubDevices
Browse a growing compatibility catalog of drives, I/O, sensors, and other SubDevices, with new integrations added frequently or upon request.
Features
Build with the motion, I/O, safety, and diagnostic capabilities needed for demanding EtherCAT machines.
Absolute or relative SCurve or Trapezoidal moves.
Modify Point-to-Point and Velocity motion trajectories on-the-fly.
Streaming trajectories to command synchronized move using PT, PVT, PVATAJ.
Define simple lines and arcs to generate complex 2D and 3D paths.
Simple constant velocity moves.
Queue moves for conditional execution.
Addition or summation of delta position between two axes to prevent skew.
Creating a move based on a defined table between the master and slave axes.
Electronic gearing based on a ration between master and slave axis.
High-precision position latching with inputs like touch probe, encoder index pulse, or home switches.
Utilize virtual axes for machine simulation.
Adjust speed of a loaded motion profile without changing the profile itself. Also known as Retrace.
Map multiple axes for synchronized and coordinated motion.
Provide a unified control interface in cartesian space for diverse robots or machines.
Execute 2D or 3D motion based on G-Code syntax.
Synchronize a moving conveyor with multi-axis (pick & place, dispensing, painting).
Use secondary feedback to close position loop. Torque mode only.
Set up triggers in motion firmware for outputs or events based on conditions in real-time deterministic manner.
Manage digital IO, analog IO, and dedicated inputs.
Execute deterministic user logic, motion control, and I/O operations without specialized real-time programming expertise.
Collect and buffer any data available in controller firmware memory.
Record motion control object errors for debugging.
Perform drive-based or master-based homing routines.
Use RMP as part of a Black Channel to cover certification requirements for IEC 61508 and IEC 61784-3.
Trigger host interruptions at a specific period/sample rate cycle.
Define axis's settling criteria conditions to for completion of a move and generate events.
Adjust command position based on motion direction. Also control the rate based on hysteresis limits.
Create a compensation table to map the accuracy of a single linear or rotary axis.
Create a compensation table to map the accuracy of a single axis relative to another or two axes.
Drive-based tuning closing the loop in the drive or master-based tuning closing the loop in RMP using PID or PIV. Torque model only.
Software
Designed to simplify the development of motion applications.
Create motion and IO applications using C++, C#, VB.NET, or Python. Communicates with RMP over shared memory for optimal performance.
Create motion and IO applications using any gRPC language (C++, C#, Python, Go, Swift, Ruby, etc.). Communicates with RMP via our rapidserver gRPC server.
using RSI.RapidCode;
// Get the X and Y axes
Axis axisX = controller.AxisGet(Constants.X_AXIS_NUMBER);
Axis axisY = controller.AxisGet(Constants.Y_AXIS_NUMBER);
// Get a multi-axis object for the number of axes defined
MultiAxis multiAxis = controller.MultiAxisGet(Constants.MULTIAXIS_NUMBER);
// Add the X and Y axes to the multi-axis object
multiAxis.AxisAdd(axisX);
multiAxis.AxisAdd(axisY);
// Abort any current motion, clear faults, and enable amplifiers
multiAxis.Abort();
multiAxis.ClearFaults();
multiAxis.AmpEnableSet(true);
// Move to the positions specified using an S-Curve motion profile
multiAxis.MoveSCurve(positions, velocities, accels, decels, jerkPercents);
multiAxis.MotionDoneWait();#include "rsi.h"
// Get the X and Y axes
Axis* axisX = controller->AxisGet(Constants::X_AXIS_NUMBER);
Axis* axisY = controller->AxisGet(Constants::Y_AXIS_NUMBER);
// Get a multi-axis object for the number of axes defined
MultiAxis* multiAxis = controller->MultiAxisGet(Constants::MULTIAXIS_NUMBER);
// Add the X and Y axes to the multi-axis object
multiAxis->AxisAdd(axisX);
multiAxis->AxisAdd(axisY);
// Abort any current motion, clear faults, and enable amplifiers
multiAxis->Abort();
multiAxis->ClearFaults();
multiAxis->AmpEnableSet(true);
// Move to the positions specified using an S-Curve motion profile
multiAxis->MoveSCurve(positions, velocities, accels, decels, jerkPercents);
multiAxis->MotionDoneWait();import RapidCode
# Get the X and Y axes
axisX = controller.AxisGet(Constants.X_AXIS_NUMBER)
axisY = controller.AxisGet(Constants.Y_AXIS_NUMBER)
# Get a multi-axis object for the number of axes defined
multiAxis = controller.MultiAxisGet(Constants.MULTIAXIS_NUMBER)
# Add the X and Y axes to the multi-axis object
multiAxis.AxisAdd(axisX)
multiAxis.AxisAdd(axisY)
# Abort any current motion, clear faults, and enable amplifiers
multiAxis.Abort()
multiAxis.ClearFaults()
multiAxis.AmpEnableSet(True)
# Move to the positions specified using an S-Curve motion profile
multiAxis.MoveSCurve(positions, velocities, accels, decels, jerkPercents)
multiAxis.MotionDoneWait()Configuration, tuning, and troubleshooting multi-platform tool. (Needs rapidserver). Developed for Linux and Windows users.
Configuration, tuning, and troubleshooting Windows tool.
Website where customers can download licenses and software releases.
A command-line app offering services through gRPC, enabling cross-OS client communication.
XML configuration and EtherCAT Network Information (ENI) generation utility.
Build, test, and deploy modern, motion-enabled, multi-platform applications with RMP using the .NET framework.
Create cross-platform applications with RMP using Qt, combining high-performance C++ motion control with modern UI design.
Apply vision from OpenCV to guide RMP motion, enabling feedback-driven tasks like inspection, alignment, and navigation.
Use the Robot Operating System (ROS) to generate motion paths and planning, then feed them to RMP for precise, real-time execution.
Hardware
Choose the platform that fits your machine, whether that’s RSI’s IPC 400 Series, another industrial PC, or a compact ARM system.
Recommended
Rugged, fanless industrial PC designed for OEMs and demanding industrial environments. Optimized and tested for peak performance with the RMP, and available with RMP pre-installed for a seamless, ready-to-use solution.
Run the RMP on the PC of your choice. Licensing is enabled through a USB dongle, which is fully transferable between systems.
Explore some RMP frequently asked questions
We offer a 30-day evaluation that is not limited to just the RMP EtherCAT motion controller. We can also provide hardware demo to free spin a motor and get started with applying all the RMP feature set.
RMP EtherCAT motion controller pricing structure based on axis count and the inclusion of premium features. This ensures a cost effective solution where OEMs pay for axis count depending on the complexity of their application. Pricing starts at $150 per runtime license.
A single RMP EtherCAT motion controller runtime license is needed per machine.
A RMP EtherCAT motion controller licenses are needed. If the INtime RTOS (not Linux) is used, then a runtime license is needed. These licenses are locked against a single USB dongle.
The RMP runtime license is perpetual and tied to the USB dongle.
Phantom or virtual axes count against licensed axis limit.
RSI offers the RMP EtherCAT motion controller and INtime RTOS runtime licenses together. Upon issuance of purchase order, RSI uploads the licenses to our portal. The download links to install the RMP and RTOS are also available on the portal.
RMP EtherCAT motion controller is compatible with most generic Industrial PCs. Industrial PCs are readily available and offered in various configurations. The OEM can select a PC and CPU with the absolute minimum processing power, squeezing the performance required for their application.
An OEM can select an IPC for their application by selecting a vendor that gives a good price, offers a short lead time, and guarantees long-term availability. With worldwide supply chain issues, the OEM can easily find a replacement IPC for their application.
Yes, RMP is a true soft motion controller that utilizes the computing power of the modern computers to provide real-time deterministic performance by utilizing the EtherCAT communication protocol.
Certainly not. RMP is a fully developed EtherCAT motion controller and offers much more than the typical EtherCAT master stacks sold in the industry.
Our RapidCode API and software tools make it very easy to program a machine, significantly reducing development time. Our RMP motion controller seamlessly handles all the configuration and setup. Our RapidCode API allows a user to deploy complex functionality in a straightforward manner so there is no laborious memory address pointers involved.
Each EtherCAT slave devices comes with an ESI file. RapidCode API and software tools enable the RMP EtherCAT motion controller to automatically detect all the nodes and establish a good EtherCAT network. This is done using a single API call or a click of a button usign our software tools. The nodes are then seamlessly presented in a tree view.
RMP EtherCAT motion controller leverages the EtherCAT communication protocol. An Ethernet port on a computer is configured and dedicated to exchanging EtherCAT data packets. EtherCAT slaves are then connected via this Ethernet port to collect and relay information.
The RMP can support more than 128 axes if needed by the application. The maximum number of axes is limited to the CPU power. A more powerful CPU can support higher axis counts.
Yes, phantom (virtual) axes can used to program and simulate using the RMP EtherCAT motion controller
The INtime RTOS runs in the background. Users only need to develop their application using our RapidCode API and utilize our software tools. We manage all the interaction between our motion firmware, the EtherCAT master stack, and relaying data to/from the EtheCAT nodes on the network.
OEMs looking to build a multi-axis and high performance machine using a PC are great RMP users. The RMP EtherCAT motion controller is PC based that can be programmed using many languages such C++, C#, VB .NET, Python, Java, Ruby, and etc.
RMP currently supports 128 axes and two sets of 64 axes can be synchronized to create a coordinated multi axis move.
RapidCode SDK is used with Visual Studio (or other windows IDE) to develop most applications.
Note: INtime SDK is only required when using RapidCodeRT premium feature.
We recommend using our iPC300 industrial products. OEMs can select their own PCs but we recommend selecting industrial computers and use Windows IoT LTSC operating system. The LTSC variant of Windows has a long life cycle and limits feature updates (not security updates). We recommend using Intel CPUs with atleast a dual or four core Celeron. 4GB RAM is recommended. An Intel NICs is recommended (as opposed to Broadcom or Realtek).
RMP EtherCAT motion controller’s firmware runs on INtime RTOS. A CPU core, memory, and Ethernet port are dedicated to the RTOS to ensure real-time deterministic traffic of data between the motion controller and EtherCAT hardware on the network. With our iPC hardware, you can run at a 4000Hz sample rate with Windows (Intime) or Linux (PREEMP_RT).
IO’s can be triggered in real-time using various RMP features. The most commonly used feature to trigger IO in RT is User Limits. Single or multiple conditions can be defined for when to trigger an IO. However, User Limits is not an option when further math logic needs to be implemented to trigger an IO RT. In those cases, RapidSequencer or RapidCodeRT is the best solution.
We support a variety of EtherCAT nodes. See our supported EtherCAT node list.
We specialize in drives which are CiA DS402 compatible and use CoE (CANOpen over EtherCAT). We can integrate new nodes if not present in our current supported list.
The default RMP sample rate is 1KHz. The sample rate can be increased up to the maximum drive interpolation rate.
RMP can run in Position, Torque, or Velocity modes. Most OEMs typically close the position loop in the servo EtherCat hardware.
RMP supports FSoE (Field Safety over EtherCAT) to add safety to an industrial machine and significantly reduce wiring over the more traditional approach of using an external safety controller.
Yes, at default we support several simple models and robotic arms we work with frequently. Other kinematic models for custom full Articulated (6 axis) serial, SCARA, and cartesian Robots can be easily added based on your needs.
Please see the following link to learn the differences: API Comparison
EtherCAT motion controllers can be a combination of both hardware and software components used where precise, synchronized, and high-speed motion control is required. RMP is a pure software based EtherCAT motion controller. RMP is installed on a RTOS core of an x86 or ARM CPU and runs in a real-time deterministic manner. One Ethernet port is used for EtherCAT data exchanges with the EtherCAT hardware on the network. The software provides a user interface for configuration, control, and generating multiple axes motion profiles (paths, trajectories, speeds, acceleration) along with feedback from sensors.
The primary industries relying on EtherCAT motion controllers include industrial automation assembly lines coordinating robots, conveyors, and other equipment. High-speed, synchronized processes for various packaging tasks, and control of CNC (Computer Numerical Control) machines for precise manufacturing. In robotics EtherCAT motion controllers enable real-time, synchronized control of multiple robot axes, crucial for industrial robots performing assembly, welding, or material handling or collaborative robots (cobots) working alongside people.
Packaging and material handling in coordination of conveyor systems, pick-and-place operations, and automating palletizing and sorting processes With Medical Equipment EtherCATmotion controllers support precise motion control with surgical robotics, diagnostic imaging systems, and medical device manufacturing. Other industries using EtherCAT Motion Controllers include:
• Automotive Manufacturing
• Food and Beverage processing
• Renewable energy
• Electronics assembly
• Building automation
• Semiconductor Manufacturing
• Test & Measurement applications
• Aerospace
EtherCAT (Ethernet for Control Automation Technology) is a high-performance network system for real-time distributed control, guaranteed timing, and the ability to synchronize multiple devices with extreme precision, making it ideal for demanding motion control tasks. EtherCAT is incredibly efficient in it’s ability to processes data "on the fly" as it passes through nodes, minimizing delays and maximizing network bandwidth. Thus EtherCAT isn't simply a standard but a whole technology encompassing both the hardware and software components necessary to create a high-performance motion control network.
An EtherCAT motion controller acts as the master device on the EtherCAT network generating motion profiles (trajectories, velocities, etc.); coordinating the actions of multiple axes/motors; sending control commands to slave devices (servo drives stepper motor drives I/O modules such as sensors); and receiving feedback from sensors and other input devices. The EtherCAT motion controller continuously sends out EtherCAT telegrams which are essentially tiny data packets that travel around the EtherCAT network carrying important information. Imagine them as mail carriers delivering updated control data for each slave and collecting data from them - and returning it back to the EtherCAT Master Controller.
This transmission of data is known as “on the fly” processing, a key feature of the EtherCAT communication protocol that significantly improves efficiency and network performance. EtherCAT’s “on the fly” processing broadcasts a single frame containing data for all devices on the network. As this frame travels along the network from one device to the next, each device can access and process the data relevant to it "on the fly," without waiting for the entire frame to be received. The device extracts its data, performs the programmed actions and modifies the frame itself, potentially adding new data before passing it on to the next device. This enables real-time communication and data exchange between devices without waiting for the master controller, minimizes device latency and improves overall system responsiveness - enabling more devices to be connected to the network without compromising performance.
“On the fly” processing is particularly advantageous for motion control applications where precise timing and fast response are critical. It allows the motion controller to send real-time updates to servo drives, receive immediate feedback from sensors, and make adjustments as needed, all within a single EtherCAT cycle. (An EtherCAT cycle is the complete process of sending commands from the master controller, processing them at each slave device, collecting feedback data, and returning it to the master within a defined time interval).
EtherCAT enables control of multiple axes with microsecond-level precision, ensuring smooth, coordinated motion and tight synchronization in a variety of network topology structures (line, tree, mesh, star, etc) of diverse slave devices. EtherCAT processes data as it passes through nodes, minimizing delays and maximizing network bandwidth usage. Standard Ethernet frames are used to carry multiple process data for numerous devices, maximizing the amount of information exchanged in each cycle. This makes it more efficient than traditional fieldbuses where data is processed sequentially at each node. EtherCAT significantly faster cycle times, better synchronization, and higher data throughput are some of the reasons why it can easily manage networks with thousands of devices without compromising performance.
EtherCAT can synchronize multiple axes with sub-microsecond jitter (timing variation), resulting in incredibly precise and coordinated motion. A built-in distributed clock system ensures accurate time synchronization across all devices on the network, further contributing to its precision. This coupled with fast cycle times explains why and how EtherCAT can handle large numbers of devices with high-speed responsive applications of without compromising performance. So for example, for robotics this means controlling multiple robot axes with high precision and speed for tasks like pick-and-place, assembly, and welding; and for CNC machines this means precise control of multiple axes in milling, turning, and other complex machining tasks. EtherCAT guarantees data delivery within specific timeframes. This ensures consistent behavior, eliminates the need for complex timing compensation, and is essential for applications sensitive to timing variations.
An EtherCAT master (MainDevice) is the central command unit or ‘brain’ on an EtherCAT network Initiating and managing all communication on the network, sending control commands to slave devices, synchronizing processes and collecting feedback data (sensor readings, status information) from slave devices.
An EtherCAT motion controller is a type of EtherCAT master/MainDevice specifically designed, focused and optimized for fast and precise motion control applications by using motion and IO algorithms that generation trajectories. All EtherCAT motion controllers contain EtherCAT master/MainDevice, but not all EtherCAT master/MainDevice are focused on motion control. Though both types of controllers initiate and manage EtherCAT communication, master controllers may have a broader scope of control and here’s how that translates into real-world applications:
A General-Purpose EtherCAT Master/MainDevice may be sufficient in a production line where a master might need to control a conveyor belt (simple, continuous motion), pneumatic actuators, various sensors, and communicate with a factory management system. Or also a simple packaging machine needing to synchronize a few axes to seal packages without requiring highly complex curves or extremely tight coordination.
However an EtherCAT Motion Controller would be more suitable for a robot arm performing complex pick-and-place operations or welding would need a motion controller capable of generating smooth trajectories, handling feedback from multiple encoders, and adapting to its environment in real-time. Or where CNC machines are needed to perform with precision control over multiple axes simultaneously, with the stringent Synchronization.
Generally speaking, EtherCAT motion controllers often have more sophisticated algorithms for generating trajectories, handling interpolation, and managing complex motion profiles, which are essential in demanding applications. They also have specialized software interfaces for directly connecting to high-precision encoders and various servo or stepper drives, streamlining integration with motion-related hardware, prioritizing real-time processing and low cycle times to guarantee accuracy and fast servo drive response.
A related blog: Why an EtherCAT Master Stack Alone Can't Facilitate Machine Production
A four axis EtherCAT motion controller is designed to handle the precise, coordinated control of up to four motors (axes) in automation systems. Consider these controllers to be ‘motion-centric’ capable of advanced trajectory planning, interpolation (calculating intermediate positions and velocities between defined target points to create smooth, controlled motion), and high-speed feedback processing. In sum, a four axis EtherCAT motion controller can generate complex motion profiles and coordinate all four motors to work in perfect synchronization, critical for applications where multiple parts of a machine need to move together with precision.
Four Axis EtherCAT Motion Controllers can be found controlling pick and place robots, small assembly robots or 4-axis SCARA (Selective Compliance Articulated Robot Arm) environments. They’re also commonly controlling precision machining tasks, particularly those with 3D curves and complex toolpaths of CNC machines and in packing, synchronizing various processes like filling, labeling, sealing, and conveying within an assembly line.
RMP EtherCAT Master and Motion Controller can support up to 128 axes of coordinated and synchronized motion. RMP is priced based on the axis counts needed so a low axis requirement would be economical to customers.
An EtherCAT Soft Motion Controller is a software-based system that turns a standard PC or industrial computer into a powerful motion control system. Generally a specialized EtherCAT motion control PC card is installed in the computer (ex: form factor of PCIe bus), managing communication and often providing some measure of signal processing for axis control. However the motion control software is the heart of the system with a user interface enabling trajectory planning covering:
• programming complex motion profiles, paths, and velocities.
• managing multi-axis coordination ensuring precise synchronization between motors
• processing feedback data from encoders, sensors, and other input devices
The motion control software on the PC enables the programming of precise commands packaged into EtherCAT telegrams (data packets) and sent over the EtherCAT network. The EtherCAT slave/subordinate devices (servo drives, I/O modules, sensors, etc.) receive these commands and execute accordingly. Feedback data from sensors and drives is sent back to the soft motion controller, thereby closing the control loop. You can customize the software, add features, and integrate it with other PC-based systems for data analysis, visualization, and more.
The complexity of applications that an EtherCAT Soft Motion Controller can handle depends largely on the motion requirements. The more axes you need to control simultaneously, the more processing power and software optimization are required. Complex trajectories (splines, 3D curves), tight synchronization needs, or high-speed changes increase computational demands. Processing extensive sensor data feedback for closed-loop control can add processing overhead thus a faster multi-core processor is critical for handling real-time motion control tasks, especially with a higher axis count or complex motion profiles.
Examples of Applications Commonly Managed by EtherCAT Soft Motion Controllers
• Mid to High Complexity Systems: Many packaging machines, CNC routers, pick-and-place robots, and complex assembly machines are suitable candidates.
• Custom OEM Designs: The flexibility of soft motion controllers makes them ideal for building specialized machines with unique motion requirements.
• PC-Integrated Applications: Where motion control needs to be combined with machine vision, data processing, or complex HMI functionalities running on the same PC.
EtherCAT motion controllers, while powerful, certainly have potential stress points or areas where careful planning and attention to detail are crucial to ensure optimal performance. Two of the key stress points are:
Large, complex EtherCAT networks require careful planning and may be more difficult to troubleshoot if problems arise. Ensuring all drives, sensors, and other components are fully EtherCAT compatible and configured correctly is vital to avoid communication errors or unexpected behavior. EtherCAT networks need proper cabling and shielding to mitigate electromagnetic Interference (EMI) and noise in industrial environments; this impacts signal integrity and timing reliability.
EtherCAT motion control of 128 motion axes refers to a large-scale automation system where a central controller such as an EtherCAT motion controller manages the precise and complex movement, data feedback, and synchronization of up to 128 individual motors (axes).
Each individual axis is controlled by its own EtherCAT servo drive, receiving commands from the controller and precisely managing its connected motor, which can be a mix of servo motors and stepper motors, depending on the specific needs of each axis (torque, precision, speed). High-resolution encoders on each axis provide critical position feedback, enabling closed-loop control and ensuring accuracy.
Designing and managing a system with 128 motion axes requires careful planning, network optimization, and a high performance software as the motion controller must calculate and send instructions to all 128 motion axes while maintaining extremely short cycle times for responsiveness. Guaranteeing microsecond-level synchronization across 128 motion axes means relying on specialized motion control algorithms followed by efficient data flow or giving certain types of EtherCAT telegrams (data packets) higher precedence over others during transmission and processing. This is crucial because it ensures the most time-critical data gets delivered without delay, even when the network is busy.
Choosing the right EtherCAT servo drives, motors, and other components for your motion control system requires careful consideration of several factors, summarized in the following steps:
Of course seamless operation requires compatibility between all components so consider the software tools provided by all parties involved in the configuration, programming, and diagnostics of the EtherCAT motion control system. It’s always good to think about potential future needs and choose components that can accommodate system expansion if necessary.
Case Studies
Over 1,000 machine builders automate with RSI. Tell us about your application and our engineers will help you get moving.
