By Dan Hebert, PE, Senior Technical Editor
Machine and robot controllers typically are programmed using off-the-shelf software packages provided by automation system suppliers. These software packages generally conform to the IEC 61131 standard, but often have custom enhancements to improve the programming experience and to get the most out of the particular supplier's controllers.
Controller programming used to be a laborious process that required creation of one line after another of arcane binary code. Graphical programming was limited to ladder logic and its pictorial depictions of contacts, coils, timers and other circuit elements. It was hard to design portable or modular software code, and often the only person capable of understanding the program was the original designer, leaving the rest of the machine design team in the dark.
Nowadays, high-level graphical programming concepts drive most controller programming software packages, and most machine builders take advantage of graphical programming features.
Before we discuss these features, it's important to note the main drawback of graphical programming: inefficient use of controller hardware resources such as processor power and memory. The lower the code level, the more efficiently it can be executed, and graphical programming represents a very high level of abstraction of the underlying code. This drawback was critical when controllers had limited memory and processing power. But modern controllers have adopted commercial off-the-shelf (COTS) technologies—greatly increasing power, speed and memory at minimal cost. As a result, graphical programming is no longer resource-limited in most applications.
[pullquote]While graphical programming provides a much easier means to program a controller for real-time control tasks, it's virtually a necessity for programming higher-level controller functions. These higher-level functions include synchronized motion, vision, remote monitoring, data logging, and real-time signal processing and analysis.
"Implementing higher-level functions on modern automation systems requires the adoption of the latest technologies such as multi-core processors, field-programmable gate arrays, and real-time operating systems," says Christian Fritz, product manager for advanced machine control and robotics at National Instruments (www.ni.com).
"Configuring and programming these technologies can be challenging, and therefore scientists and engineers look for advanced engineering tools such as our LabView software," he says. "The graphical programming features in it reduce development costs and shorten time to market with their ability to graphically design, prototype and deploy software programs."
Leading benefits of graphical programming tools include a high level of abstraction, faster software development and a unified development environment. A high level of abstraction allows one graphical element to represent many lines of code and/or many separate graphical programming elements.
For example, a command to move a robot arm from one position to another might require many lines of detailed code and numerous function blocks. Representing this entire operation with one graphical element can make a program much easier to understand, especially for those not intimately familiar with controller programming nuances.
Users achieve faster software development because graphical programming lends itself to the creation of function blocks that are reusable across applications. Controller and graphical programming software vendors provide a number of pre-programmed function blocks to execute various common machine and robot control tasks. Reusing internally created and externally available function blocks is a huge time-saver during both software development and commissioning.
Graphical programming makes a unified development environment (UDE) possible. A UDE allows one software package to be used for programming multiple controller targets implementing a wide range of control and information processing tasks. In many cases, different targets and tasks require vastly different underlying code. Converting this code to function blocks or other graphical elements, all with a common look and feel, makes a program created in a UDE intelligible to a wide range of users by organizing graphical elements into coherent patterns.
