Realtime Systems

In industrial automation, robotics, and CNC systems, achieving hard real-time determinism is crucial for safety, precision, and performance. Many systems rely on costly proprietary solutions to meet those demands—but OpenCN offers an open, modular alternative specifically built for embedded motion control with microsecond-level timing precision. Released under the GPLv2 license, OpenCN promotes transparency, adaptability, and long-term sustainability—making it an excellent foundation for building reliable, real-time automation systems without vendor lock-in.

OpenCN is ideal for developers and integrators looking for affordable, real-time, and production-grade control systems that don’t compromise on timing guarantees or long-term maintainability.

OpenCN originates from the well-known LinuxCNC project, whose architecture has powered machine tools and motion platforms for decades. However, traditional LinuxCNC relies on either soft real-time or hybrid userspace/hard real-time setups, often with considerable complexity or overhead.

🧠 Real-Time Core: Xenomai/Cobalt, Streamlined and Evolved

At the foundation of OpenCN lies a customized hard real-time core based on Xenomai/Cobalt. Unlike traditional implementations, OpenCN’s version removes the I-Pipe layer—a legacy abstraction once required to enable real-time co-kernels within Linux. This results in a lighter, cleaner, and more maintainable integration with the Linux kernel.

This architecture not only reduces latency and jitter but aligns with the forward-looking design principles of Xenomai 4 / EVL—while retaining the mature and proven scheduling and interrupt management features of Cobalt.

Benefits include:

• Hard real-time determinism
• Reduced system overhead
• Compatibility with recent Linux kernels
• Customizability for embedded deployments

The overall picture below shows the general OpenCN environment.

OpenCN General Architecture

⚙️ Multicore Isolation for Determinism

OpenCN fully leverages asymmetric multicore processing, a key strategy for ensuring hard real-time behavior in modern multi-core systems. This allows:

• Time-critical control loops to run on dedicated CPU cores
• Background tasks such as networking, data logging, or user interfaces to be confined to separate cores
• A predictable and interference-free real-time environment

This isolation model is essential for systems where control loops must execute with fixed cycle times, regardless of system load.

💻 Runs on x86 and Raspberry Pi 4/5

OpenCN runs natively on both:

• x86 industrial PCs for performance-intensive applications
• ARM-based platforms, including Raspberry Pi 4 and 5, for compact and low-cost deployments

This range of support makes it well-suited for:

• Prototyping motion systems
• Retrofitting legacy equipment
• Deploying cost-sensitive automation solutions
• Educational and academic use cases

Despite its efficiency, OpenCN delivers the hard real-time behavior expected in high-end industrial controllers.

🔌 EtherCAT for Real-Time Industrial Communication

OpenCN includes native support for EtherCAT drivers, allowing deterministic, synchronized communication with:

• Servo and stepper motor drives
• I/O expansion modules
• Distributed sensors and actuators

EtherCAT is the primary fieldbus supported, ensuring seamless integration into modern industrial automation ecosystems. This makes OpenCN particularly well-suited for motion control platforms, where high-speed field communication is critical.

📡 User Interface and System Monitoring

OpenCN includes a remote user interface, which can run on a separate PC or tablet. This interface allows users to:

• Configure the system
• Monitor machine operations in real time
• Visualize and log control signals
• Optimize control parameters based on process feedback

Such capabilities are essential for maintaining high precision and quality in automated machining and robotic workflows.

🛠 EDGEMTech: Your Partner for Real-Time Embedded Control

At EDGEMTech, we have deep experience with OpenCN—many of our engineers were directly involved in its development and deployment. We offer:

• Long-term support and maintenance
• Custom adaptations to specific hardware platforms or motor drive integrations
• Kernel and driver-level customization to meet hard real-time requirements
• Consulting on deploying OpenCN in production systems or as part of Industry 4.0 strategies

Whether you’re building a CNC machine, an advanced robot, or a precision automation line, EDGEMTech can provide the expertise and support to make OpenCN a stable, tailored, and sustainable solution.

🔧 Summary

OpenCN proves that hard real-time control, open-source freedom, and embedded efficiency can go hand in hand.With native EtherCAT support, deterministic execution, and lightweight architecture, it offers a powerful foundation for next-generation control systems.

🔗 Learn more about OpenCN

We invite you to share your experiences, ask technical questions, or explore OpenCN’s capabilities with us here in the Realtime Systems section.

Let’s build deterministic systems—together.

The release of Linux RT-Preempt Kernel 6.12 marks another significant step in enhancing real-time performance for critical applications. This version introduces improved low-latency scheduling, deterministic behavior, and better IRQ handling, providing a more stable foundation for industrial automation, robotics, and other real-time workloads.

With enhanced IRQ threading, latency spikes are significantly reduced, even under high-load scenarios. The improved preemptibility ensures consistent response times for real-time applications, making the system more predictable. CPU isolation techniques have also been refined, minimizing jitter and improving determinism.

Additionally, real-time scheduling policies have been optimized, increasing efficiency for time-sensitive operations.

However, some areas in the kernel still pose potential risks for latency spikes during real-time operations. For instance, the seccomp() syscall triggers a call to the tlb_flush_all() function, which invalides all TLBs on all CPUs.

On an x86 machine with an SMP configuration, this function relies on a special APIC mechanism to broadcast IPIs to all CPUs in a single instruction. The problem? There’s no check against an isolated CPU, which should not be disturbed especially if an RT application is performing constant read/write operations. The IPI results in a CPU interrupt, introducing a latency spike.

Here’s a excerpt of function call path:

tlb_flush_all(void) -> ... -> x2apic_send_IPI_allbutself() -> .. -> __wrmsr()

tlb_flush_all(void) -> ... -> x2apic_send_IPI_allbutself() -> .. -> __wrmsr()

At the end, there is only one instruction doing the work:

static __always_inline void __wrmsr(unsigned int msr, u32 low, u32 high)
{
	asm volatile("1: wrmsr\n"
		     "2:\n"
		     _ASM_EXTABLE_TYPE(1b, 2b, EX_TYPE_WRMSR)
		     : : "c" (msr), "a"(low), "d" (high) : "memory");
}

static __always_inline void __wrmsr(unsigned int msr, u32 low, u32 high)
{
	asm volatile("1: wrmsr\n"
		     "2:\n"
		     _ASM_EXTABLE_TYPE(1b, 2b, EX_TYPE_WRMSR)
		     : : "c" (msr), "a"(low), "d" (high) : "memory");
}

Fortunately, there’s a workaround: pass the no_ipi_broadcast=1 argument to the kernel command line. A simple fix, but not an obvious one! This problem became apparent when we noticed unexpected high latency spikes when performing basic operations such as ssh’ing to the remote machine running an RT application.

.

Looking Ahead

Beyond these considerations, Linux RT-Preempt 6.12 continues to push the boundaries of real-time performance, making it an excellent choice for embedded systems and time-critical applications. As adoption grows, its impact will likely extend further into robotics, telecommunications, and automotive systems.

Looking forward to sharing insights and experiences on its implementation in various real-time environments!

If your embedded system requires real-time constraints, don’t worry! The Linux operating system remains a top choice. With significant advancements in the upstream RT-PREEMPT extension over the past three years, you can now run applications on isolated CPU cores with minimal latency and jitter.

However, some specific use cases—particularly those requiring hard real-time performance in user-space applications—can be tricky. Combining RT and non-RT tasks in the same environment may lead to interference, and implementing non-GPL closed-source code within the kernel only adds to the complexity.

For these challenges, the EVL (Xenomai 4) extension is a powerful alternative to RT-PREEMPT. Here’s why

:

• Out-of-Band (OOB) Functions: Guarantee hard real-time conditions across execution paths, ensuring deterministic behavior for critical tasks.
• Clean RT/Non-RT Separation: Isolates the real-time domain from standard Linux tasks, minimizing interference.
• Scalable Architecture: Works seamlessly on popular ARM-based SoCs, such as Raspberry Pi, NXP, TI platforms, making it versatile for various embedded projects.
• Hard Real-Time User-Space Applications: Ideal for scenarios where real-time functionality must remain closed-source without relying on kernel modifications.

Whether you’re tackling hard real-time constraints, maintaining user-space applications, or working with ARM-based systems, EVL offers an innovative and reliable solution.

It’s definitely worth considering for your next project!

Have you ever thought that x86 would gradually leave the world of embedded systems?

The Sapphire Edge+ VPR-4616-MB is a Mini-ITX motherboard that includes the AMD Versal AI Edge VE2302 device plus an AMD Ryzen Embedded R2314 processor, along with a flexible I/O interface to connect to various peripherals and sensors.

Our Engineers are on hand to give you the necessary expertises in hard realtime systems based on Linux for your new development, if you envisage to start a new product or to port an existing realtime systems.

Hard realtime systems is the third axis of competences we have at EDGEMTech.

It concerns all aspects (development, tuning and optimization, porting, debugging, etc.) related to hard realtime systems (mainly x86 and ARM Linux-based systems).

Do not hesitate to contact our expert Daniel Rossier for any advice.