Implementing a reconfigurable machine controller using FPGAs -

Implementing a reconfigurable machine controller using FPGAs


High performance machines often require specialized control algorithms and advanced synchronization with sensors and vision systems. These requirements can be difficult or impossible to achieve with fixed function motion controllers and drives, and turning to custom design often isn't feasible.

A fully reconfigurable motion control architecture based on the combination of an FPGA, real-time processor, and modular I/O can be used to implement specialized high performance systems more effectively than traditional approaches.

Motion Control: Traditional vs. Reconfigurable
Fixed function controllers and drives ship with firmware that implements behavior that cannot be modified by the end user. These controllers and drives could be optimized for a specific purpose such as driving a CNC endmill spindle, or designed with the intent to be as generic as possible to cover a wide variety of applications within or even across industries.

As long as you operate within the designed use case, these fixed function controllers and drives are usually the most effective choice for implementing an application because you can take advantage of all the design work and feature definition that went into that product, such as advanced filtering, auto-tuning, test panels, diagnostic tools, and a host of other features baked into the firmware.

The problem with fixed function controllers arises when you, as a machine builder, need to step outside the capabilities defined by the motion controller and drive firmware. Unfortunately you may end up in a situation where you are able to complete 95% of your application with a traditional controller or drive, but that last 5% forces you to abandon the entire design and search for a new solution. These scenarios become more common as machines become more specialized and increasingly sophisticated.

The alternative solution machine builders often turn to is custom design. With a custom built motion controller or drive, a machine builder can define exactly the behavior they want to see out of the system. However, custom design is costly, time-consuming, and has its own set of limitations.

Custom solutions can be challenging to build and manufacture requiring a full team of engineers with a specific set of skills. They also include the burden of creating revisions for life-cycle management due to bugs or part availability. Perhaps the most important limitation is that, because of their specific design, the custom solution is likely not a good fit for new features or for the next project.

The result is a continuous cycle of custom design that can be difficult to break, and this is a problem, especially for smaller companies that need to be as agile and lean as possible in their operation. Alternatively, the design and manufacturing can be outsourced to a third-party company, but this approach is expensive and can expose any specialized IP.

So how do you combine the full feature sets and performance of fixed function devices with the ability to customize them as needed for specified applications?

You need a persistent framework that can be developed along the lines of a fixed function device with lots of testing, iterative feature improvements, and the like, but that also is modular such that components of the system can be completely defined by the user to meet very specific and demanding application needs.

The progression of computing technology and reconfigurable embedded design tools (specifically FPGA technology) makes this combination of fixed functionality and custom design benefits possible. The combination of a programmable real-time processor, programmable FPGA, and modular I/O packaged into an off-the-shelf system adds much of the needed flexibility for building control and measurement systems. A diagram of this architecture is shown in Figure 1 .

Figure 1: The architecture of a reconfigurable motion control system

Taking this concept to software is also important. The ability to reconfigure a standard framework; customizing where necessary but still utilizing the rest, is very useful for machine builders. In this software architecture, motion tasks are disaggregated so that largely you can choose where to run a particular task to meet the needs of the application.

Furthermore, each task or block is open, that is, you can modify the functionality down to a low level. Finally, machine control software packages should be constructed to be modular, such that specific tasks could be modified and customized without largely impacting other blocks in the system. This modular approach is to a large extent hardware agnostic, meaning that you can mix and match components to come up with the HW system that meets your needs in terms of axis count, processing power, integration with other I/O subsystems, and level of customizability.

Let’s take a closer look at some of the technologies needed by today’s high performance machine builders that are not well met by fixed function controllers and drives.
Specialized Control Algorithms
For systems that requirenon-standard control, having a reconfigurable system can mean thedifference between a simple code-change and a costly redesign. This isrelevant at the drive firmware level in FPGA, as well as at thesupervisory control level in the real-time controller.

One FPGArelated example involves replacing a common velocity or position loopwith a loop running closed-loop force control. This can be done in orderto test material strength, measure button quality, or simulate a fingerpress on a touch panel. A modular design not only allows you to use thecontrol algorithm of your choosing, but supports easy integration of aforce sensor and any necessary signal conditioning. Other examples couldinclude replacing hall-effect sensors with a custom startup routine fora brushless motor, or replacing a standard PID function with a moreadvanced control algorithm.

In the case of the real-timecontroller, a modular design allows a developer to easily program theirown inverse kinematics equations for non-standard coordinate spaces inaddition to using the traditional trajectory generator. The real-timecontroller could also be used for other advanced tasks like using amodel-based control algorithm.

Advanced Synchronization with I/O and Vision
Highperformance machines commonly require some type of synchronization withother subsystems, and this can take many different forms. Test systemsmay need to correlate data acquisition to specific real-world positions.

Control systems often need to setup custom triggering based on avariety of conditions to perform tasks in real-time. Implementingmotion on a platform with modular I/O means that you can mix and matchspecific I/O to meet system requirements without necessarily having toincur the cost of integrating a separate tool chain for the measurementI/O.

Having an RT system with an ecosystem of availablecomponents means easier integration of motion, vision, and I/O systemcomponents. Having a programmable FPGA allows for custom hardware leveltriggering and signal analysis beyond what is capable on standard motionand automation platforms.

Perhaps the most common benefit anFPGA provides in this architecture is the ability to define customtriggering based on information from the motion controller. For example,imagine trying to precisely trigger a large collection of valves forprecise durations at specific positions, features that would be requiredwhen implementing a printer-like application. This would likely beimpossible to do with a traditional motion architecture. However onceyou combine modular IO with a high-speed FPGA that is aware of currentposition, the problem now becomes relatively easy to solve.

Agrowing use case for this type of synchronization with real-timeprocessors is vision-guided motion. The real-time processor can processimage data, calculate positions, and command those positions to motorsconfigured in a coordinate space. Vision-guided motion of this natureopens the door for a wide variety of exciting possibilities.

Integration of Disparate Motor/Drive/Control/Feedback Types
Forlower level control, basically at the drive firmware level, you havethe ability to use the FPGA for a variety of common motion controltasks. These include control loops and commutation schemes, motion I/Olike an encoder read, reading limit switches, implementing filters, andso on. The nice thing here is that you can dig in and customize just thepieces that you need. By targeting very specific portions of FPGA codefor modification, you can achieve the flexibility you need and still getan application up and running very quickly.

The flexibility thisapproach provides is very powerful. You can use it to easily achievecoordinated motion with a FPGA controlled drive and an external smartdrive from two different manufacturers. You could also coordinate manydifferent types of motors, and use a different type of feedback foreach, all without changing the existing trajectory generation or moveprofile software. In essence, any functionality provided by usingmodular I/O and an FPGA can be integrated into an axis of motion, andthat axis of motion can be integrated with other axes of wildlydifferent configurations.

This technology isnot always the best fit for every application; if your application isstraightforward and it falls within the uses cases the large fixedfunction controller and drive manufacturers design for, then you canprobably design the system at a lower cost and more quickly usingtraditional motion systems.

However, if you are pushing the edgewith a high performance machine that needs to be better, faster,smarter than the previous designs, you will probably run into caseswhere you need advanced I/O, custom synchronization, specialized controlalgorithms, or to integrate disparate or non-standard subsystems. Inshort, you will be stepping outside the boundaries defined bytraditional devices, and when you do so, a reconfigurable architecturebecomes the most effective way to implement these systems.

Burt Snover is a Systems Engineer at National Instruments specializing in Embedded Systems and Motion Control. As a CertifiedLabVIEW Architect, Burt has years of experience assisting customers withsystem design ranging from high-level software frameworks to low-levelFPGA algorithms. Burt holds a Bachelors Degree in Electrical Engineeringat the University of Texas at Austin and joined National Instruments in2008. This paper was part of a class he taught at the Embedded SystemsConference on “Fully Reconfigurable Motion Control for Embedded MachineDesign (ESC-312).”

Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.