|
APIs, concepts, guides, and more
|
|
|
APIs, concepts, guides, and more
|
Which RMP API to use, and when application code needs real-time.
RMP has one programming API: RapidCode. It is the same user-space library, with the same classes and methods, compiled for Windows, Linux, and INtime. You can call it from C++, C#, VB.NET, or Python, and from another machine over RapidCodeRemote.
The RMP firmware is the real-time part of the system. It closes the servo loops and runs the EtherCAT network on a deterministic schedule no matter how your application is written. Your application code sends commands and reads status, and for most machines it does not need to be real-time at all.
Some applications do need a piece of their own logic to run every sample with guaranteed timing, such as a custom sensor feedback loop. For those, RMP provides Real-Time Tasks (RTTasks). See 🔹 When Your Application Code Needs Real-Time below.
| Binding | Language | Windows | Linux | INtime |
|---|---|---|---|---|
| RapidCode | C++ | ✅ | ✅ | ✅ |
| RapidCode.NET | C#, VB.NET | ✅ | ✅ | ❌ |
| RapidCodePython | Python | ✅ | ✅ | ❌ |
| RapidCodeRemote | gRPC (any language) | ✅ (host) | ✅ (host) | ❌ |
RapidCode.NET and RapidCodePython are thin wrappers over the C++ library. Simple getters cost a few hundred nanoseconds per call even through the C# wrapper. Choose the language your team is productive in.
RapidCodeRemote runs rapidserver on the Windows or Linux PC that hosts RMP and accepts gRPC clients from any language on any machine. Every call crosses the network, so use it for supervisory control and tooling (this is how RapidSetupX works), not for tight loops.
The firmware is always deterministic. This section is only about the less common case where your own code must run with guaranteed timing, for example a control loop that reads a sensor and updates a command every sample.
Windows cannot do this on its own; Windows users get real-time by running that code on INtime. Linux with a PREEMPT_RT kernel and INtime can both run application code in real-time threads. On any of these you have two options:
| Option | Platforms | Who manages the real-time thread | Requires |
|---|---|---|---|
| RTTasks (recommended) | Linux, INtime (Windows for debugging only) | RTTaskManager, in lockstep with the RMP sample clock | RTTasks feature; on Windows, the standard INtime Runtime that RMP already uses |
| Your own real-time thread | Linux (SCHED_FIFO), INtime (RapidCodeRT) | You | Linux: RapidCode only. INtime: RapidCodeRT feature plus the full INtime SDK |
RTTasks is RMP's managed real-time framework. You write plain C++ task functions that use RapidCode, compile them into a shared library, and the RTTaskManager loads, schedules, and monitors them every sample alongside the firmware. Priorities, timing statistics, safe shared data (GlobalData), and debugging on Windows are built in. Your main application stays in whatever language you prefer and submits tasks by name.
RTTasks is the recommended path on both Linux and INtime because it gives you deterministic application code without requiring real-time operating system expertise. It is a separately licensed feature. On Windows it runs on the standard INtime Runtime that RMP already requires; you do not need to buy the INtime SDK.
RapidCode reads and writes the firmware's shared memory directly, so a call made from a real-time thread is as deterministic as that thread. On Linux you can call RapidCode from a SCHED_FIFO thread on a PREEMPT_RT kernel; on INtime every RapidCodeRT process is already real-time.
This is the do-it-yourself path for real-time operating system experts. You own thread priorities, CPU affinity, memory locking, avoiding allocation and blocking calls, and synchronizing safely with your non-real-time code. RSI supports RapidCode in this configuration but provides no tooling for it. When in doubt, use RTTasks.
| If you... | Use |
|---|---|
| Want the fastest path to a working machine | RapidCode.NET or RapidCodePython on Linux or Windows |
| Need your own logic to run every sample with guaranteed timing | RTTasks on Linux or INtime |
| Are on Windows and need real-time application code | INtime, with RTTasks or RapidCodeRT directly |
| Are a Linux real-time expert and do not want the RTTasks feature | RapidCode C++ in your own SCHED_FIFO thread |
| Need to control the RMP from a different computer | RapidCodeRemote |
What is RapidCodeRT?
RapidCodeRT is the INtime build of the RapidCode C++ library (RapidCodeRT.lib, RapidCodeRT.rsl). It is the same API as RapidCode on Windows and Linux. The "RT" means the library runs inside an INtime process, which is always real-time. It is a separately licensed feature because INtime development requires additional support from RSI.
There is no RapidCodeRT for Windows or Linux. On Linux, the standard RapidCode library called from a SCHED_FIFO thread on a PREEMPT_RT kernel is technically just as real-time as RapidCodeRT on INtime. See API Comparison.
Can I use RapidCode in a real-time thread on Linux?
Yes. RapidCode works directly on the firmware's shared memory, so calls made from a SCHED_FIFO thread on a PREEMPT_RT kernel are deterministic. No extra library or license feature is needed beyond RapidCode for Linux.
This is a do-it-yourself path: you are responsible for priorities, CPU affinity, memory locking, avoiding allocation and blocking calls, and safe synchronization with your non-real-time code. If you are a real-time operating system expert, go ahead. Otherwise we recommend Real-Time Tasks, which manages all of that for you and is what RSI supports and tests.
Why choose RTTasks over RapidCodeRT?
RapidCodeRT on INtime means writing your entire application as an INtime process. That requires purchasing the full INtime SDK from TenAsys, building with the INtime toolchain in Visual Studio, and handling INtime-specific concerns yourself: process and thread priorities, memory allocation rules, inter-process communication with your Windows code, and debugging inside the INtime environment.
RapidCode on Linux in a real-time thread avoids the SDK cost but needs the same class of expertise: a PREEMPT_RT kernel, SCHED_FIFO scheduling, CPU isolation and affinity, locked memory, no allocation or blocking calls on the real-time path, and safe lock-free handoff to your non-real-time code. Get any of it wrong and you have jitter that is hard to see and harder to debug.
RTTasks gives you deterministic application code on both platforms without any of that. You write ordinary C++ task functions, and the RTTaskManager runs them every sample alongside the firmware, handles priorities and timing statistics, and exchanges data safely through GlobalData. On Windows it needs only the standard INtime Runtime that RMP already requires, not the INtime SDK. Your main application stays in C#, Python, or C++ on the host OS. See Real-Time Tasks.
What are the INtime RapidCodeRT development requirements?
1.15.0