Machine Design
Embedded Virtualization Clears a Path to PC-Based Machines

Embedded Virtualization Clears a Path to PC-Based Machines

The PC architecture is emerging as a leading computing platform for integrating all computing elements of a typical factory workcell. However, fulfilling this role effectively requires special operating software.

Many OEMs strive to maximize plant productivity by allowing machines to perform multiple operations simultaneously. Some of these concurrent operations will involve human interaction, but others may be computationally intensive and/or time-critical. To keep less time-critical tasks from impacting those with a deadline, machines have been built with multiple computing platforms. Typically, these incorporate one or more motion controllers, and one or more supervisory processors that support the operator interface for programming, machine operation, data collection, and maintenance functions. However, using multiple processors is costly. Coming to the rescue is new software specifically targeted at PC platforms.

Download this article in .PDF format
This file type includes high resolution graphics and schematics when applicable.

The economies of scale that have driven PC software architecture to dominate the office environment are also significantly impacting industrial control. Simply put, the cost of PC hardware is much less per unit of computing power than that of proprietary control systems, such as special-purpose PLCs and motion controllers, whether standalone or coprocessor-based. Hundreds of software companies are competing to lend functionality to the PC that was previously available only in special-purpose units.  Now, the PC software platform is becoming a nexus for integrating smart machines and workcells in the factory. 

With the right operating software, modular applications for many machine functions can be combined on a single, partitioned, multicore PC-compatible computer. The real-time computing and control requirements can run reliably without the cost of numerous devices (chassis, power supplies, and so on.)  The question is whether a particular application that once incorporated multiple discrete computing units is able to perform as well after integrating tasks onto one computing platform. The key enabler is embedded virtualization, a software technology that lets multiple workloads run on the system at the same time, including one or more real-time operating systems.

Building Blocks

The human machine interface (HMI) was the first machine application hosted on PCs, in the 1980s, and subsequently the PC architecture became the standard platform for operator interfaces and machine maintenance stations. Then, in the 1990s, PC-based software was developed to implement the functions of the programmable logic controller (PLC). 

PLCs got their start as programmable computers, which replaced fixed electromechanical or digital logic for sequencing machine operations (e.g., simple motor and valve controls) with programming methods that mirrored the setup of the relay ladders they supplanted. PLC programming has evolved over the last 10 years to provide much more functionality and easier program development and maintenance. Proprietary languages have been merged into standards such as IEC 61131, and intuitive, graphical programming interfaces are now commonplace. Today, PLCs typically serve as supervisory controllers to initiate and sequence machine processes and monitor machine operation.

After solving some reliability problems that plagued early PC software platforms in industrial environments, software companies began implementing PLC applications on the PC.  Because Windows is the most popular software-development platform for the PC architecture, lending itself easily to the development of powerful graphical user interfaces, most so-called “soft PLC” applications for the PC are hosted on Windows.

The Need for Determinism

Discrete PLCs and PLC applications hosted on general-purpose operating systems such as Windows or Linux have their limitations, though. One case in point, and a critical one at that, is closed-loop motion control.  Closed-loop control involves responding to hardware events within a particular time window. Consider, for example, a welding robot that must trace out a welding path according to a particular CAD design. Following each movement, it must be ready to perform the next motion step. However, if the instructions for that step aren’t executed in time, it will likely impact weld quality. 

The control loop in this scenario might involve receiving electrical pulse streams from multiple rotary encoders attached to motors on the robot axes to determine the welding head’s current position. Then it obtains target position information for the next motion step from the CAD database; calculates the motion required to get to the next point in the weld; and sends control outputs to the motors to move the welding head accordingly. To keep the welding process smooth and precise, the response needs to be made before a hardware-enforced deadline.  The ability to respond in real-time is also referred to as determinism. Not all soft PLCs, such as those with reaction times (scanning times) of 100 ms or more, have this capability.

Real-time operating systems (RTOSs) were developed for the PC to support applications such as soft PLCs that require a high degree of determinism. Software companies provide RTOS software that runs alongside the Windows operating system (OS) on the PC platform. The ability to run multiple operating environments on the same platform is called virtualization.

This Intel quad-core processor incorporates the explicit hardware partitioning of an operating system environment by Microsoft Windows and two INtime RTOS instances.

A special form of virtualization—embedded virtualization—ensures real-time responsiveness using a hypervisor, or through explicit hardware partitioning of the underlying processor architecture. In the example shown above, hardware partitioning is accomplished with standard Windows application program interfaces (APIs), enabling Windows to run without any modification on its assigned processor core(s). Such a partitioned system extracts as much as possible from the processor resources, unlike other multi-OS configurations requiring hypervisors, because there’s no hypervisor layer consuming computing cycles. New software systems are enhanced to optimize use of the constantly evolving Intel Architecture hardware and software platforms, including providing ongoing support for the Microsoft Visual Studio development environment and software APIs to create Windows HMI and controller applications.

Integrating the Elements

Software companies exploit this technology by producing embedded runtime software that provides standard (IEC 61131) PLC control functionality with real-time responsiveness in the sub-millisecond range. To ensure this performance, the control portion of the embedded software is hosted on an RTOS. Successful application suites will take advantage of both operating environments: the RTOS for meeting the deterministic control requirements of the application, and Windows for program development and debugging.

The PC hosting trend for industrial software hasn’t stopped with soft PLCs, though. Over the past few years, motion-control application software was developed to take advantage of RTOS platforms, and interface standards, such as EtherCAT (Ethernet for Control Automation Technology), were developed so that PCs could interface directly to motor drives.

One provider, Industrielle Steuerungstechnik GmbH (ISG) of Stuttgart, Germany, developed “soft motion” software that leverages a real-time operating environment for the PC. PC-based robotic platforms, for example, include a modular motion kernel that runs on a PC. This kernel can control multiple motion axes, with a comprehensive set of special functions for CNC-type applications.

PC-based simulation software from ISG (called ISG-virtuos) and other companies allows machine developers to build and drive a virtual model of a motion engine to prove output motion functionality for implementation on the final machine application. The simulator uses the motion kernel to drive the simulation, and displays a visual representation of the motion system (perhaps a robot) on the computer screen. 

“Our advantage is that our motion kernel is very general, enabling us to fulfill the requirements of different applications with a modular approach,” said ISG Project Leader Hannes Richter.  “For example, one of our projects combined four different companies’ software building blocks on the same system: TenAsys INtime RTOS providing processor partitioning and real-time scheduling, Phoenix Contact’s PLC runtime for supervisory control and HMI, an EtherCAT master interface by Koenig-pa GmbH (Nuremberg, Germany) connecting to the motor drives, and ISG’s motion kernel doing the motion control. EtherCAT was a good choice because it is well-supported with devices all over the world.”

Richter added, “For debugging, TenAsys’ INscope tools give oscilloscope functionality and give a deep look into the system so we can see what is happening in real-time, regardless of the software manufacturer of the particular module.”

With security becoming more important when connecting machines to the Internet, another increasingly important building block for integrated machine software environments is the firewall. Ultimately, it allows the platform to serve as a host processor for future “Internet of things” (IoT) applications. 

The illustration below shows a complete integrated workcell incorporating all of these elements. A big advantage to building systems with modular building blocks is the ability to mix and match best–in-class system elements.

Software building blocks can all combine to produce a powerful, Internet-enabled “workcell on a PC.”

“Machine tool builders want to be open to choose their own components so that they can take the best component from each company,” said Hannes Richter. “And they need to know that they have a scalable platform.”

“The solution is very open,” echoed Boris Waldeck, Marketing Manager for Phoenix Contact Software. “Especially in the last few years, platforms with multicore processors have become very common in the market. With programs such as the INtime system—a multicore PC platform—different functions can be distributed on various cores; for example, one core for the supervisory control, one for motion control, and one for fieldbus communication. And nowadays, platforms are becoming available with four or eight cores. Platform technology is reducing limits to the amount of functionality that designers can integrate.”

With the technology advances described in this article, including operating environments that support embedded virtualization, the trend toward highly integrated machine workcells based on PCs is poised to accelerate.

Download this article in .PDF format
This file type includes high resolution graphics and schematics when applicable.
TAGS: Embedded
Hide comments

Comments

  • Allowed HTML tags: <em> <strong> <blockquote> <br> <p>

Plain text

  • No HTML tags allowed.
  • Web page addresses and e-mail addresses turn into links automatically.
  • Lines and paragraphs break automatically.
Publish