Today�s PC-based test systems free engineers from much of the mundane task of programming at the hardware level or even at the software level. Applications are built by assembling tests with function libraries or connecting graphical blocks or objects together with wires dictating the program flow. The next-generation GUI builders, however, can virtually eliminate programming, freeing engineers to concentrate on test functionality rather than implementation details.
Programmable instruments have become the norm in today�s test and measurement world. The ability to send commands to an instrument over a network to control its operation and read its data has allowed engineers to turn individual test instruments into complete test systems.
First using GPIB and most recently the LAN extensions for instrumentation (LXI), test engineers have been able to coordinate the operation of many diverse instruments to produce custom test systems and automate test sequences. The result has increased test efficiency as well as reduced errors.
Likewise, over recent years, various standardized software interfaces have become well established. For example, through the efforts of organizations such as the IVI Foundation, common software interfaces have been defined to standardize the programming of similar type devices from different vendors.
Test engineers can swap instrument modules for equivalent ones from a second source or upgrade to a higher-performance version without altering code. This standardizing of software interfaces to hardware contributes so strongly to reducing design time and simplifying maintenance that the U.S. Department of Defense will not even consider the purchase of instrumentation without standardized programmability.
Control of these programmable instruments traditionally has been accomplished using languages such as C++, Visual Basic, or LabVIEW. Text-based programming such as C and Visual Basic are traditional software development languages. To use these languages, a programmer first must master all of the details of the language and then write the program to implement the desired operations.
Graphics-based languages like LabVIEW improved the situation quite a bit. With a graphical language, it�s possible to begin writing programs much more quickly. Since all of the elements of the language are visual rather than text, you can much more easily start writing simple programs. It is just a matter of wiring graphical objects together.
With all of these programming languages, a huge variety of additional tools, add-ons, libraries, and instrument drivers also is available. The add-ons and built-in tools and libraries go a long way toward simplifying many common programming tasks.
For example Visual C++.Net comes with well-integrated support for the entire .NET framework that provides pre-built and tested tools for a large number of the most common programming tasks. These tools give you great flexibility and detailed control over all the aspects of your application�s look and feel and the GUI�s operational details.
In addition, whenever you buy specialized measurement and control equipment such as a data acquisition board, it inevitably comes with libraries that can be called from these standard programming languages. These libraries take care of the details of controlling the board or device.
Similarly, LabVIEW also ships with a large number of building blocks that simplify the job of the programmer. Because LabVIEW was designed for instrumentation and control-type applications, it also includes quite a bit of built-in support for devices and instrumentation. In other languages, that type of support generally is provided as add-on software by the hardware manufacturers.
On the other hand, programming can be quite complex and difficult to develop and revise as test needs and instruments change. For complex operations, many developers turn to professional programmers rather than test engineers to create the software.
The test engineer specifies the desired operation and then waits for the programmer to develop the code. Developing tests in this manner requires detailed knowledge of each instrument�s command set. It also can be slow and error-prone, subject to all the debugging challenges of other text-based software.
It often is possible to write simple programs with very little experience with the programming language. For example, with a graphical language, it is quite easy to create some complicated programs wiring together pre-built objects. The learning curve is quite short, and those programs can be very powerful.
Application Builder
For more in-depth requirements, you must begin to master the underlying details of the programming language: control flow, data structures, logical and mathematical operators, and data types. That is, you must become a programmer if you aren�t one already.
The alternative to writing programs with LabVIEW, C++, or Visual Basic is to use a GUI builder program. It is much simpler to use, and you don�t need to be or become a programmer. In general, if you can find a GUI builder program that does everything you need, then it�s typically a much simpler solution than writing a program.
Historically, though, the big downside to using a GUI building program is its lack of flexibility. Also, you can�t take advantage of the ever-increasing wealth of instruments, devices, and software that becomes available.
Recently, however, next-generation GUI builders have begun to address these challenges. Measure Foundry 5.0, for example, allows engineers to create test and measurement applications without needing a programming language (Figure 1). The application builder provides drag-and-drop objects placed onto forms to be configured for the desired behavior using property pages. The application builder creates a real Windows application using a GUI so the user doesn�t need to know how to program at all.
Because Measure Foundry is an application program rather than a programming language, it�s very simple to create complex applications without mastering the details of a programming language. In addition, its support for standardized software interfaces goes a long way toward addressing any potential lack of flexibility that application programs typically have.
Whenever you need to choose software tools for a given job, the most important step is to carefully construct a detailed list of the necessary requirements. From there, it�s wise to review the available applications programs that are on the market. If you can find an available GUI builder program that can meet your requirements, it should be the quickest and easiest method of solving the task at hand.
In some cases, it�s not possible to find a GUI builder program that meets your exact requirements, either because you have a very specialized type of job or very specific needs about how to accomplish the job. In those cases, you�ll need the ultimate flexibility of a full programming language like LabVIEW or C++. Wherever possible, it�s best to avoid programming if there is a workable application program available.
Tools like Measure Foundry can get most jobs done quickly and efficiently without forcing you to become computer programmers. They allow you to focus on the details of the test task at hand rather than the details of a programming language.
Conclusion
With the trends toward hardware commoditization and the drive toward modular and synthetic instrumentation, graphical approaches are the future of test development. As powerful as they are, however, traditional programming languages still require a programming mindset. Next-generation GUI builders show that these requirements also can be eliminated, allowing test engineers to set up sophisticated programmable instrument systems without ever writing a line of code.
About the Author
Tim Ludy is a product marketing manager at Data Translation. Mr. Ludy graduated from Northeastern University with a B.S. in computer science. Since 1987, he has held many positions from production technician to application engineer. Data Translation, 100 Locke Drive, Marlboro, MA 01752, 508-481-3700, e-mail: [email protected]
FOR MORE INFORMATION
on Measure Foundry 5.0
www.rsleads.com/705ee-195
May 2007