Real-time control systems play a critical role in industrial automation. Machines need to respond instantly to sensor feedback, update motion trajectories precisely, and execute tasks deterministically. Despite their importance, programming these systems traditionally requires specialized knowledge, often leading to complex, expensive, and time-consuming development cycles.
Real-Time Tasks simplifies real-time programming. This helps machine builders and software developers create strong, responsive machines more quickly than ever.
Machine builders can write user logic, motion, and I/O code to run in a real-time deterministic manner. You can use RTTasks to serve a specific machine operation, or the entire machine can leverage RTTasks.
What Are Real-Time Tasks?
Real-Time Tasks helps developers write and run custom real-time RapidCode. This works with the RMP EtherCAT master and motion controller.
Real-Time Tasks makes it easier to run real-time user logic. This includes IO processing, custom control loops, and complex motion logic. It does this in a scheduled and predictable environment.
Developers can easily define their real-time tasks. They do not have to handle low-level real-time operating system (RTOS) calls.
They also do not need to manage thread synchronization. They do this by using clear and structured C++ functions called RTTasks. Real-Time Tasks then manages thread creation, scheduling, synchronization, and communication automatically, delivering the consistency required for industrial automation machines.
Why is Real-Time Programming Traditionally Difficult?
Real-time programming historically demands deep expertise because of the stringent timing and synchronization requirements. Developers must typically manage complexities such as:
- Thread Management: Ensuring threads execute precisely at set intervals without interference.
- Priority and Scheduling: Managing priorities, so critical tasks run without delays.
- Synchronization and Resource Sharing: Handling data safely across threads without causing race conditions or deadlocks.
- Debugging Complexity: Real-time code often behaves differently under standard debugging tools, complicating troubleshooting.
These challenges frequently limit real-time control to specialized engineers who know a lot about RTOS. This increases project timelines and costs.
How Real-Time Tasks Simplifies Real-Time Programming
With Real-Time Tasks, RSI offers a simpler way to handle complexity. This lets software developers and engineers focus on the main application logic instead of the underlying infrastructure.
Key simplifications include:
- Automatic Thread Management: The framework automatically handles creation and real-time scheduling of threads, ensuring deterministic timing.
- Built-in Scheduling and Priority Handling: Tasks run automatically at set intervals. Developers can easily set priorities using simple API calls. This avoids the complexities of managing priorities manually.
- Safe Communication happens between real-time tasks and non-real-time client software. You can achieve this by using simple global variables that are easy to understand. These variables ensure consistent and safe data exchange without manual locking or complex synchronization logic.
- Enhanced Debugging Support: Real-Time Tasks lets developers test real-time logic in non-real-time mode on Windows. They can use familiar tools like Visual Studio before deploying in real-time mode. This significantly improves the efficiency of troubleshooting.
A Practical Example: Real-Time Sensor Feedback
Imagine a laser-based height sensor used in CNC machining or 3D printing equipment. Traditional non-real-time control loops might introduce noticeable latency or jitter, reducing accuracy and performance. With Real-Time Tasks, developers can easily create a deterministic real-time feedback loop:
- Sensor Reading: Each Real-Time Task cycle reads data from the height sensor precisely once per millisecond (at a typical 1 kHz cycle rate).
- Real-Time Processing: The data is processed instantaneously—such as filtering or averaging readings—within the same deterministic cycle.
- Immediate Motion Adjustment: Axis positions are adjusted on-the-fly on the next cycle, providing smooth, accurate real-time correction.
Previously, creating such responsiveness required significant RTOS-specific knowledge or custom hardware solutions. Now, Real-Time Tasks enables this capability through straightforward C++ functions and a simplified API.
Supported Platforms and APIs
Real-Time Tasks supports multiple platforms, further enhancing flexibility and integration possibilities for developers:
- Operating Systems: Runs on both Windows (using the INtime real-time subsystem) and Linux (using PREEMPT_RT), enabling deployment on your preferred platform.
- Programming Languages: Tasks are implemented in C++ for optimal performance, but control and management can be seamlessly integrated from C#, Python, or other supported languages through RSI’s RapidCode APIs.
Comparison with Other Solutions
Compared to traditional RTOS-based solutions or even RapidCode RT (RSI’s earlier real-time programming approach), Real-Time Tasks significantly lowers the barrier to entry. Unlike solutions that require purchasing specialized development kits or SDKs, Real-Time Tasks offers built-in simplicity, better productivity, and ultimately, lower total cost of ownership.
Getting Started with Real-Time Tasks
Integrating Real-Time Tasks into your industrial automation project is straightforward:
- Write your real-time logic as concise, simple C++ functions.
- Compile your tasks using RSI’s provided tools for Windows or Linux.
- Deploy tasks onto RMP via the Real-Time Task Manager.
- Monitor and debug tasks using familiar tools like Visual Studio or RapidSetup’s built-in diagnostics.
Conclusion
The Real-Time Tasks (RTTasks) feature is a game-changer in industrial automation, designed to simplify real-time programming for machine builders, automation engineers, and software developers. With RTTasks, you can build high-performance, responsive machines without needing extensive expertise in real-time systems.
Whether you're working on advanced robotics, precision CNC machines, automated packaging systems, or complex testing setups, RTTasks delivers reliable, deterministic real-time control to power your industrial automation projects with ease.
Ready to transform your real-time programming approach?
Contact RSI today to learn more about Real-Time Tasks and see how we can help accelerate your next industrial automation project.