PRODUCT HOW TO - Embedding multicore PCs for Robotics & Industrial Control

PC-compatible industrial computers are increasing in computing power at a rapid rate due to the availability of multi-core microprocessor chips, and Microsoft Windows has become the de-facto software platform for implementing human-machine interfaces (HMIs).

PCs are also becoming more reliable. With these trends, the practice of building robotic systems as complex multi-architecture, multi-platform systems is being challenged. It is now becoming possible to integrate all the functions of machine control and HMI into a single platform, without sacrificing performance and reliability of processing.

Through new developments in software, we are seeing industrial systems evolving to better integrate Windows with real-time functionality such as machine vision and motion control. Software support to simplify motion control algorithm implementation already exists for the Intel processor architecture.

Motion control algorithms
Motion control algorithms are generally implemented using (from simplest to most complex): PID (Proportional Integral Derivative) equations, IIR (Infinite Impulse Response) filters, or MRAC (Model Reference Adaptive Control) algorithms. PID and IIR are probably the most common, due to their relative simplicity in analysis and implementation.

If someone is dealing with a single-axis controller it will probably be implemented using one of these filters. MRAC (aka MRAS) algorithms are far more complex and are generally used to deal with difficult to characterize systems and may utilize PID or IIR algorithms for the actual controller part of the system.

In the simplest case, the math is one-dimensional, meaning simple "difference equations" that involve performing a series of multiplications and additions (and possibly divides and subtracts) on a sequence of sampled data inputs and, depending on the algorithm, prior outputs to produce a control output value that is sent to a control actuator (thus closing the control loop).

The number of data points, or "taps," processed by the algorithm is a function of the "order" of the controller, or the complexity of the filter, and might involve a small array of current and prior input and output samples (where the inputs are typically the measured positions and/or velocities, etc.) or even 10s or 100s of taps.

For example, an application may need to "pre-filter" the sampled input data stream to remove unwanted noise, requiring that the control algorithm work with many data points (i.e., a large input vector) in a pre-filter to generate a decimated sequence of "smoothed" input data points for the controller, or perhaps to synthesize a velocity signal from sampled position data.

In complex controllers, especially coordinated multi-axis systems, the control calculations may become more cumbersome than just a few simple multiplications and additions; The math can turn into matrix arithmetic, transforming into matrix multiplication and inversions.