- Benefits of Programming Graphically in NI LabVIEW - National Instruments
- An Intro to Labview and Graphical Programming Languages
- Table of Contents
Graphical languages usually are developed using a graphical interface, where elements are selected and the underlying sections, where functionality is added. The details are dependent on the language. It requires licenses, although student and trial packages are available. A student edition was used for this article.
Benefits of Programming Graphically in NI LabVIEW - National Instruments
LabVIEW was designed to support a laboratory environment and is targeted to applications to control and monitor equipment. To support this effort, NI has a wide selection of hardware interfaces and meters to enable LabVIEW programs to monitor and control electronic equipment. Signals from the hardware interfaces can be read directly by the program and the data acted upon. Knowing the engineering behind the process to be controlled and measured is as important as knowing LabVIEW. An RF power meter, like the one shown below is needed to interface to the RF modules.
An Intro to Labview and Graphical Programming Languages
The meter provides measurements that can be read by the program, which compares the measured power to the specification. Output can be files or any of the visual displays and graphs included in the controls menu. Although this article only introduces LabVIEW, it is robust enough to control an entire test lab or control multiple systems. Users groups are located in various locations where users meet and share information.
Help and documentation can be accessed from within the program. The Front Panel window provides tools menus and all the controls needed for the application. Programming is done by selecting functional controls in the Front Panel window; if appropriate, a corresponding block is added to the Block Diagram. In addition to functional controls like signal generators, buttons, displays and graphs, decorative controls that only affect the Front Panel are also provided.
These allow similar controls to be visually grouped together and have the Front Panel to look similar to real equipment or be as detailed as desired. The Block Diagram is where the inputs and outputs of the various controls are wired together. The program can be run, aborted, and paused from either the Front Panel or the Block Diagram. The Block Diagram also provides troubleshooting aids.
The light bulb will highlight the execution path as the program runs. An example of the differences between languages using statements and a graphical language like LabVIEW can be illustrated by a comparison of how repetitive actions are controlled. A typical For Loop may look like the code block below.
This loop outputs to the statements to the screen the number of times provided by index.
The loop is put in place, and all the elements to be repeated, referred to as 'code' in the LabVIEW documentation, are placed within the loop. The Index is set to the number of iterations needed. The code within the for loop executes the required number of times. There are explicit constructs for handling events and VIs like buttons employ this type of action inherently. Parallel programming often has to deal with time, so it is not surprising that LabView addresses this in a number of ways from time-oriented loops to time related and configurable VIs.
VIs are comparable to subroutines but they are also similar to objects because they have state. The big difference in the latter case is that a VI alone has only one callable method.
A LabView class is actually a collection of VIs and controls. A control essentially maps to a variable in other programming languages. The VIs have access to the controls providing the commonality of a class as well as an identifiable object. Any of the defined VIs can be applied to a matching object, and objects can be created as necessary. The method VIs are what will be wired up in a program. The one common item among a class' VIs will be an input and output for the object.
In CLOS' case, the function called is the one that most closely matches the types of each input parameter, including objects.
VIs are inherited in subclasses and they can redefine superclass VIs. It makes sense from an implementation standpoint. It is not bad once you get used to it though.
- Navigation menu?
- Terzetto: Ah! qual colpo inaspettato!, No. 19 from Il Barbiere di Siviglia - Full Score.
- Purchase Options;
- What Do You Want to Learn Next?.
- LabVIEW - Wikipedia.
LabView can create standalone programs that run on PC. Of course, they can also be run from within the LabView environment, and this is one reason why LabView development can be so productive. The interactive nature is great for development and learning purposes. Still, one of LabView's recent benefits is the ability to target non-PC platforms. This is something relatively recent for a year old environment.
Table of Contents
It is also one of the more interesting aspects, since LabView can be used with a range of targets — even within a single application. It can also generate conventional source code such as C that can run on most microcontrollers. The Blackfin DSP support is more as a standalone programming target. VIs are available for a range of filters that are optimized for the Blackfin and interfaces that exist on the chip or the development boards. Given the way LabView supports a high level of productivity, the latter is often very desirable.
As noted earlier, LabView can handle the entry of C code, and other scripting languages, in a LabView program so developers can choose the most appropriate method of algorithm entry. These two examples highlight LabView's capability but they are by no means the only way developers can target non-PC platforms. So far I have been waxing mostly on LabView's many advantages.
Given the number, it is not surprising that LabView has such as large following. In closing I want to touch on some of the cons along with some of the pros I have not already mentioned. LabView is a proprietary language and development environment. In many ways it matches another successful, although more conventional environment: The big difference is that there are no compatible compiler alternatives to LabView's G language. There is a learning curve with LabView. It can sometimes be harder for programmers than non-programmers since the former will almost always need to unlearn techniques that are different in LabView.
This is especially true when trying to take advantage of LabView's features. Old habits are forced onto newly available features, so things like array manipulation are done using for loops. Optimization is another issue, although National Instruments has done an amazing job when targeting native code.
Still, understanding the environment and compiler can be more difficult since the user is far removed from the underlying system. This is similar to Java, but even there the quality of the system has essentially made the issue moot. On-screen code density can be another issue. Graphical programs take up lots of space and the lack of zooming makes it imperative to implement a hierarchical structure of VIs. Larger screens and multiple displays can help especially with the advent of lower cost displays and availability of multiple display video adapters.
Text code can be denser on-screen, but a graphical representation is often easier to evaluate quickly. The presence of source code manipulation tools is one advantage of the non-graphical programming solutions. Tools like grep and awk as well as refactoring support in environments like Eclipse allow developers to make massive contextual changes that cannot be done in a graphical environment simply because this type of search and replace tool has yet to be developed. Some UML tools now support graphical difference tools that are very handy when combined with source code management tools, but graphical tools in general tend to be lagging their text-based counterparts.
Still, there has been little new in the text arena along these lines, either. The final item is essentially related to the proprietary nature of LabView and its closed nature. LabView lacks many of the third party optimization and diagnostic tools found with other programming languages and development environments.