COSC 414

LabVIEW

Graphical programming for instrumentation.

Pramuditha Suraweera
 Contents

1. Introduction ...................................................................................................................3

2. Purpose of language ......................................................................................................3

2.1 Extra features.............................................................................................................3

3. Historical roots...............................................................................................................4

4. Language style ...............................................................................................................5

4.1 Data representation....................................................................................................5
4.1.1 Numeric ..............................................................................................................6
4.1.2 Boolean...............................................................................................................7
4.1.3 String ..................................................................................................................7
4.1.4 Path and Refnum ................................................................................................7
4.1.5 List and Ring ......................................................................................................8
4.1.6 Array and Cluster ...............................................................................................8
4.1.7 Graph and Chart .................................................................................................8
4.1.8 Wires...................................................................................................................8
4.2 Operations..................................................................................................................9
4.2.1 Numeric operations ............................................................................................9
4.2.2 Boolean functions.............................................................................................10
4.2.3 String functions ................................................................................................10
4.2.4 Array functions.................................................................................................11
4.2.5 Cluster functions...............................................................................................11
4.2.6 Comparison functions.......................................................................................11
4.2.7 Time and Dialog functions ...............................................................................12
4.2.8 File I/O functions..............................................................................................13
4.2.9 Variables...........................................................................................................13
4.3 Control and Chunking .............................................................................................14
4.3.1 Structures..........................................................................................................14
4.3.2 SubVI................................................................................................................15
4.4 Programming environment......................................................................................15
4.4.1 Basic environment ............................................................................................15
4.4.2 Debugging ........................................................................................................15
4.4.3 VI Hierarchy.....................................................................................................16

5. Sample program ..........................................................................................................16

6. Discussion on programming experience....................................................................19

6.1 Positive features.......................................................................................................19
6.2 Negative features .....................................................................................................20

7. References ....................................................................................................................22

2
1. Introduction
Laboratory Virtual Instrument Engineering Workbench (LabVIEW) is a powerful and
flexible instrumentation and analysis software system [2, 3, 5]. It uses a graphical
programming environment that uses the construction of virtual instruments as a metaphor
[4]. The programming aspect of LabVIEW is similar to a creating flowcharts where icons
are wired together to perform various functions.

The next section of the report consists of a description of the purposes and features of
LabVIEW. Section 3 looks in to the historical roots of the system. The aspects of he
language style such as data representation, operations, control and chunking and
programming environment detailed in section 4. A sample program created in LabVIEW
that provides visual representation of graphs is given in section 5. The last section
consists of experiences in programming.

2. Purpose of language
LabVIEW was created with the main purpose of providing engineers and scientists a
programming environment, which is intuitive to them. The main focus was to provide a
powerful and quick software development alternative for the production floor, the test
department and the research laboratory [7]. It has replaced conventional program writing
with building virtual instruments. The front panel user interfaces of the instruments can
be created quickly and easily, which provides interactive control of the software system.
The functionality of the instruments can be specified by assembling block diagrams
which is a natural design notation for engineers and scientists.

2.1 Extra features

Other than being a powerful simulation tool LabVIEW can be used to gather data from
external sources [1]. It is equipped with a number of built in virtual instruments that can
be used for this purpose. Data acquisition is the process of bringing signals from physical
phenomena such as voltage in to the computer for processing, analysis, storage or other
data manipulation. Sensors, who sense these physical phenomena, produce electrical
signals. LabVIEW can be used to command plug-in data acquisition (DAQ) boards to
acquire and generate analog and digital signals. This acquired data can then be analyzed
using LabVIEW virtual instruments (VIs). Monitoring temperature, sending signals to an
external system and determining frequency of an unknown signal are some of the
applications of DAQ.

General Purpose interface bus (GPIB) was developed to facilitate communication

between computers and instruments. LabVIEW GPIB VIs automatically handle the
addressing and most other bus management functions, saving the user the hassle of low-
level programming [1]. GPIB is mainly used to communicate with oscilloscopes,
scanners, multi-meters and live instruments from remote locations.

3
Serial communication is a popular way transmitting data between a computer and another
computer or a peripheral device such as a programmable instrument. The LabVIEW
serial library consists of functions used for serial port operations [1]. Any instrument that
can communicate using the RS-232 protocol can be connected using serial
communication.

As LabVIEW analysis VIs provide popular data analysis techniques in discrete Vis [3],
they can be wired together to analyze data. This property nullifies the burden of thinking
about implementation details for analysis routines (which is not the case in most
programming languages) and concentration can be directed on solving data analysis
problems [4].

LabVIEW analysis VIs, cover the following major areas in processing:

• Pattern recognition
• Digital signal processing
• Digital filtering
• Smoothing windows
• Statistical analysis
• Curve fitting
• Linear algebra
• Numerical analysis
• Measurement-based analysis

3. Historical roots
National Instruments corporation first began research on a software-based system that
automates laboratory instrumentation and data acquisition in April 1983. This research
led to the evolving of virtual instruments (VI) concept. The result of the research was a
software system that consisted of a front panel user interface and a block diagram
programming method [1].

LabVIEW is based on the graphical data flow programming language G. This was first
introduced by National Instruments as the programming language behind LabVIEW. G
simplifies scientific computation, process monitoring and control, and test and
measurement applications, and you also can use it for a wide variety of other
applications. Other National Instruments products and toolkits have taken the
functionality of G to enhance the customer’s industry-specific needs.

The research continued till 1986 where National instruments released the first version of
LabVIEW. This particular version was developed for Macintoshes only. The reason
behind the choice of Macintosh was their graphical nature best accommodated LabVIEW
at the time.

4
The LabVIEW system code was completely rewritten during the late 1980’s with new
software technology and taking customer feedback in to consideration. The result was the
release of LabVIEW version 2 in January 1990. One of the attractive features of the new
improved LabVIEW was that the execution speeds of VIs being comparable with
programs created in C programming language.

During the year of 1990 the innovative technology of LabVIEW was recognized by the
United States Patent office and several patents were issued.

National instruments ported LabVIEW to other platforms, namely PCs and workstations.
In 1992 LabVIEW for windows and LabVIEW for Sun was introduced to the market.

LabVIEW version 3 arrived in 1993 for Macintosh, Windows and Sun operating systems.
LabVIEW 3 programs written on one platform can run on another. This multi-platform
compatibility gave the users the opportunity to choose a development platform while
ensuring that the created VIs could run on other platforms.

LabVIEW supported group of platforms grew in 1994 to include Windows NT, Power
Macintoshes and HP workstations. The adoption of Windows 95 was brought about in the
year 1995.

The year 1996 introduced LabVIEW 4 which features a more customizable development
environment so users can create their own workspace to match their industry, experience
level and development habits. It also added high-powered editing and debugging tools for
advanced instrumentation systems and Object Linking and Enabling (OLE) based
connectivity and distributed execution tools.

The most recent addition to the LabVIEW family is LabVIEW 5, which was released in
1998.

4. Language style
The programming language used in LabVIEW is the graphical programming language G.

4.1 Data representation

LabVIEW VIs consist of a front panel and a block diagram. The front panel is a
combination of controls and indicators. Controls are inputs from the user. They may also
be interpreted as sources or terminals. As labview was developed as a software based
system that automates laboratory instrumentation, controls simulate typical input devices
that would be found in conventional instruments. Knobs and switches are typical
examples of such controls. Indicators on the other hand are outputs to the user
(destinations or sinks). These are designed to simulate output displays that show data that
the program generates. Gauges, meters and graphs are popular examples of indicators.

5
Data representation objects can be categorized in to the following;

• Numeric
• Boolean
• String
• Path and Refnum
• List and Ring
• Array and Cluster
• Graph and Chart

4.1.1 Numeric

LabVIEW provides the programmer with a vast collection of numeric control and
indicators. Digital, slide and rotary are the major categories of front panel numeric
objects. Figure 1 shows a collection of sample front panel objects.

Fig 1: Some examples of numeric controls and indicators

The front panel objects can be used as both controllers and indicators. They are
distinguishable in the block diagram. In the block diagram, a control has a thick outline
and an indicator has a thin outline. Figure 1 shows the difference between the block
diagram structures of a control and an indicator.

6
 Control Indicator

Fig 2: Block diagram structures of control and indicator

Numeric data in LabVIEW is categorized in to floating point numbers and integers.

Double precision, single precision and extended precision are some of the example types
of floating point. Unsigned 32-bit, unsigned 16-bit, 32-bit and 8-bit are examples of
integer types. The numeric type of a terminal should be specified during the
programming phase.

4.1.2 Boolean

Boolean controls simulate mechanical push buttons, toggles switches and slide switches.
Figure 3 provides a collection of typical boolean front panel objects.

Fig 3: Boolean controls and indicators

The corresponding block diagram structures of controls return boolean values of true or
false where as indicators take in a boolean value and outputs it using the front panel
object.

4.1.3 String

The front and block diagram structures use string controls and indicators to input and
output strings. A character would be a string of length one. There are many built in
operations that can be perform string conversion to numeric and vise versa.

4.1.4 Path and Refnum

These are used to enter and display the location of a file or directory in a file system
using the standard syntax for a given platform. Empty path appears as an empty string in
the control but is interpreted differently in different platforms. For example in Windows

7
it refers to the drivers mapped to the computer, in Mac platform, the empty path is the
files on your desktop and on UNIX, the empty path refers to the root directory.

When a file is opened, its path should be specified. A refnum is returned identifying that
file. Refnum is a unique number that is assigned to a file as it is opened. It can be viewed
as a file pointer. The opened file’s refnum is used in all subsequent operations relating to
that file. In closing a file its refnum is disassociated from the file.

4.1.5 List and Ring

A listbox presents the user with a list of items. The item names are represented as string.
Rings are special numeric objects that associate numeric values with strings, pictures or
both. Rings can be particularly useful for selecting mutually exclusive items.

4.1.6 Array and Cluster

An array is a collection is a variable-sized collection of data elements that are all the
same type, where as a cluster is a collection of data elements of mixed types. Array
elements are indexed from 0 to n-1. Clusters are also ordered internally according to the
order in which the type were added to the cluster.

4.1.7 Graph and Chart

A graph is a two dimensional display of one or more plots. The graph should be given the
data as a block. Chart, however update the display point by point as the data is received.
Some example of graphs and charts in LabVIEW can be seen in figure 4.

4.1.8 Wires

LabVIEW VIs are held together by wires connecting nodes (program execution elements
and objects that represent front panel objects). These are the data paths between sources
and destinations. The concept of using wires to connect nodes has brought about the
notion of data flow through the wires. A function or a data sink gets activated only after
data from all the input wires arrive. Wires are only visible in the block diagram.

The color and its thickness of a wire depict its data type. For example wires carrying
floating point numbers are orange in color, integer blue, boolean green and wires carrying
strings are purple. The wire is thicker if it is carrying an array and it gets even thicker as
the dimension of the array increases.

LabVIEW refuses connections of mismatching data types. Connecting two controls or

two indicators by a wire is also illegal. In the case of attempting to make an illegal
connection the wire would appear to be broken.

8
 Fig 5: Graphs and charts

4.2 Operations
Nodes are execution elements of a block diagram. Functions are elementary nodes built
in to G. They perform elementary operations like basic numeric operations, file I/O and
string formatting. Functions do not consist of a front panel object.

4.2.1 Numeric operations

The numeric functions of the graphical programming language G can be categorized in to

arithmetic, complex, conversion, logarithmic, and trigonometric operations. Functions
such as addition (+), subtraction (-), absolute value (| |), sum (∑) and square root (√) are
some of the basic arithmetic operations. G also consists of a function that produces
random numbers between 0 and 1. Some example terminals of numeric operations are
given in figure 6. Note that the basic structure of the numeric function terminal is a
triangle, which consists of the respective symbol that depicts its functionality.

LabVIEW also consists of nodes that return the numeric values of special constants such
as pi (π), natural logarithm base (e) and gravitational constant (G). These block diagram
nodes are square in nature, with symbols that identify the respective constants. Some

9
examples of functions that deal with complex numbers can be used to find the conjugate,
conversion of complex to polar and vise versa. There exist conversion functions that can
perform conversion of a number to 8 bit integer, single precision float and long integer
etc. Exponential, power of 10 and natural logarithms are some instances of logarithmic
functions. Trigonometric functions such as sine and cosine take in an integer and return
the sine or cosine it (see figure 6 for sample block diagram nodes).

Fig 6: Some examples Numeric functions

4.2.2 Boolean functions

Boolean values in LabVIEW are represented as T and F for true and false respectively. It
consists of Boolean functions such as AND (∧), OR (∨), NOT (¬) and implies (⇒).
These functions take 2 arguments of type boolean and returns a boolean value according
to the corresponding truth table. The function “and array elements” takes in an array of
boolean elements and returns the resulting boolean value after performing the AND
operation to all the array elements. The base two representation of an integer can be
found using the “number to boolean array” function.

4.2.3 String functions

LabVIEW consists of a number of functions that manipulate strings. “String length”,

“concatenate strings” and “split strings” are some of the common functions that perform

10
operations on strings. Functions such as “format in to a string” and “format date/time
string” function are useful in formatting strings. More advanced functions such as “scan
string for tokens” can be used in parsing strings.

Numbers can be converted decimal, hexadecimal and other representations using the
additional string to number functions. String conversion functions provide utilities to
convert strings to paths and other types. Strings can be converted to all caps using the
upper case function and vise versa with the lower case function.

Fig 7: String manipulation functions

4.2.4 Array functions

The graphical programming language G consists of a vast variety of array manipulation

functions. Functions such as array size, retrieve array element and replace array element
are some of the basic array functions. G also consists of other built in array functions
such as rotate 1D array, sort 1D array and array min and max perform more advanced
functions with arrays. Arrays can also be converted in to clusters and clusters to arrays
with the respective built in functions.

4.2.5 Cluster functions

LabVIEW consists of functions that unbundle clusters, bundle individual components to

clusters and builds an array of clusters.

4.2.6 Comparison functions

Most common comparison tests such equal, greater, less and greater than or equal etc.
can be added to the block diagram program. These comparison functions are triangular in

11
nature with their respective symbols. Functions that compare numbers to zero can be used
to test whether a given number is for example equal to zero and greater than zero.

The function select, takes in a boolean value, one value that would be returned if the
boolean value is true and another if the boolean value is false. The minimum and
maximum of two numbers can be found using the min & max function. A check can be
performed in order to check whether a given character represents a decimal digit, a
hexadecimal digit or an octal digit. There also exists a function that performs lexical
analysis. It takes in a character and returns its class. Characters are grouped in to 7 class
of which digits, uppercase characters and lower case characters are some examples.

4.2.7 Time and Dialog functions

The functions provided by LabVIEW can use to get the current time, measure elapsed
time, or suspend an operation for a specific period of time.

The function tick count (ms) returns the value of the millisecond timer, which produces a
number between 0 and 231. This function can be used to measure small amounts of time.
It can also be used in waiting for a certain period of time, but there is a function who’s
sole functionality is to wait for a given period of time. It is possible to halt execution for a
certain number of milliseconds using the function “wait”. The other function “wait until
next ms multiple”, waits until the value of the millisecond timer becomes a multiple of
the specified constant. This function is useful to synchronize activities. It can be called in
a loop to control the loop execution rate.

One button dialog box, simple error handler are some of the examples of dialogue
functions. Both these functions bring up a dialog box that contains a message that may or
may not consist of buttons.

Fig 8: Time and dialog functions

12
4.2.8 File I/O functions

The set of file manipulation functions include most commonly used file managing
functions such as open, close, read and write. These read and write from a given offset
position and return the contents of the file in a byte stream. The function
open/create/replace file opens an existing file, creates a new file or replaces an existing
file, programmatically or interactively using a file dialog box.

Functions that deal with more specific types of files also exist. Read and write characters
to a file are functions that enforce restrictions on material on the file. Spreadsheet files
can also be manipulated using the read and write to spread sheet functions. There are
other functions that perform modifications to binary files.

Some of the file system functionality such as file/directory info (size, last modification
date, whether its a directory), move files, copy files, delete files and access rights can be
performed using LabVIEW built in functions.

Fig 9: File functions

4.2.9 Variables

Global and local variables can be used in G programming.

Local variables are mostly used reading data from controls in multiple locations of the
block diagram. They can also be used in treating a front panel object as a control in some

13
locations and an indicator in other locations. Global variables store data used by several
VIs.

Global and local variables are not recommended to be used often because they make the
understandability of the program difficult. Both these variables hide the data flow of the
block diagram.

4.3 Control and Chunking

4.3.1 Structures

Structures are nodes that supplement the flow of execution in a block diagram. It is
similar to the functionality of control structures in a conventional programming language.
The icon for a structure in G is a resizable box with a distinctive border that can be used
to identify the type of structure. G consists of the following structures,

• For loop
• While loop
• Case structures
• Sequence structures

Structures also start execution when their input data is available, and they supply data to
their output wires only when execution completes.

Fig 10: Structures

The block diagram that resides with in the structure border is called the subdiagram. The
loop structures have only one subdiagram but case and sequence can have many
subdiagrams depending on their functionality.

When data is passed in and out of structures LabVIEW automatically creates terminals
where the wires cross the boundary. These terminals are called tunnels. For and while
loops can index and accumulate arrays at their boundaries automatically. This capability

14
is called auto-indexing and it creates a new element for each loop iteration. The output of
a loop would be an array, if auto-indexing is enabled where its elements correspond to
loop iterations.

Shift registers, which are available in For Loops and While Loops, are local variables that
transfer values from the completion of one iteration to the beginning of the next. A shift
register has a pair of terminals where the right terminal stores the data at the completion
of an iteration and that data is shifted to left terminal at the end of the iteration. Multiple
shift registers can be created on a particular structure.

4.3.2 SubVI

A subVI is similar to a subroutine in a text based programming language. It is a VI that is

used in the block diagram of another VI. Any VI that has an icon and a connector can be
used as a subVI in another VI. VIs can not be used recursively.

4.4 Programming environment

4.4.1 Basic environment

LabVIEW VIs consist of a front panel and a block diagram. The programming
environment of a VI consists of 2 separate windows, one for the front panel and the other
for the block diagram. The front panel window is used to create a graphical interface for
the virtual instrument and the block diagram window is used to specify the functionality
of the VI in the graphical programming language G. Adding a controller or an indicator
to the front panel adds the corresponding icon that represents it, in to the block diagram
window.

A tool bar exists which contains the run, abort and format commands, which are relevant
in execution and formatting the font of text and alignment of text. The tools required in
operations such as positioning, labeling, and wiring etc. can be found in a separate
window named tools. Similarly two other windows exist that consist of a controls pallet
and a functions pallet.

4.4.2 Debugging

LabVIEW consists of debugging operations such as execution highlighting and stepping

instructions. Break points can be added at any part of the diagram in order for the
execution to halt at a particular time. When the execution highlight mode is selected and
a program is executed, an animation of the data flow can be seen in the block diagram
window. Instructions can be stepped through by either executing one instruction or
executing a subVI. The data that flows through a wire at any given time can be found by

15
using the Probe tool. The execution of a VI can be halted or stopped at any time during
the execution. The halting option can be very useful when used in conjunction with the
execution highlighting.

4.4.3 VI Hierarchy

A graphical display of the calling hierarchy of all VIs in memory can be obtained using
the graphical hierarchy window. It also includes the types of definitions and global
variables. This function is very useful in building VIs that consists of multi level
hierarchies. The ordering of the VIs in to a tree structure visually represents the nested
VIs. This reduces the mental load on the programmer. Each VI can be assigned a textual
description of its behavior. This information aids the programmer in the identification of
a particular subVIs.

5. Sample program
An equation demonstration program was developed in LabVIEW. This program can
visually display the graph of functions of form,

Y = aX3 + bX2 + cX + d

The program consists of 4 controls that let the user input values for the four constants a,
b, c and d. It also consists horizontal slide that lets the user set the range of the variable
X. The button on the bottom of the graph swaps the X and Y axis. The general equation
on the top panel is sensible to the input values of a to d; if any of them hold a value of
zero, the respective term vanishes from the top panel. The front panel of the equation
demonstrator is given in figure 11 (page 17).

The block diagram structure of the VI (Fig 12 and 13, page18) includes a sequence
structure that enforced the action of assigning the attributes of all the terms on the top
panel to be visible. Even though the default value of attribute is visible, in the case of a
previous execution run the terms have a possibility of being invisible.

The main loop of the program is a while loop which loops until the stop button is pressed.
The block diagram with in the loop, perform checks on the values of a to d and assign
them to be visible or not. The values of y, which correspond to x values in the given
range are calculated by a for loop. The resulting points are wired in to the array indicator
and the graph.

16
Fig 11: Front panel of equation demonstrator

17
Fig 12: Block diagram of equation demonstrator with CASEs set to true

Fig 13: Block diagram of equation demonstrator with CASEs set to false

18
The block diagram structure used to find the result of a value raised to a certain power
was generalized in to a subVI. The subVI block diagram is given in figure 14. It takes in
two arguments, a number and its power. The power of a certain number is found by
accumulating a number by multiplying it by it self. Shift registers are used to transfer
values from one loop iteration to the other.

Fig: 14 Block diagram structure of power VI.

6. Discussion on programming experience

6.1 Positive features
The programming language is very intuitive. It is based on the principle of designing
circuits, where nodes that perform operations are wired up together for the data to flow
from one node to the other. Creating VIs using this block diagram metaphor has
simplified programming.

Most of the icons that are used for functional nodes are clear-sighted. Just observing the
icon can identify their functionality. They also consist of optional text labels that increase
the identifying ability of icons. This feature of LabVIEW can be extremely helpful for
part time programmers that would be using the software rarely. The nodes for front panel
objects can be located with the command find terminal or find indicator. This command
highlights the node corresponding to the front panel object. Optional labels can be
attached to these nodes to increase understandability of the block diagram.

Since skilled professionals are the main users of the system, so quick and easy learning to
create VIs should be an essential feature of the system. The icons are created using
common symbols found in circuit diagrams. This feature helps engineers in identifying
their functionality. It reduces the mental complexity of the users. It helps the average user
of the system, engineers, to achieve high productivity in minimum time.

LabVIEW is the only graphical programming system with a compiler that generates
optimized code with executions speeds that are comparable to compiled C programs.

19
This feature allows the user to increase productivity with graphical programming with out
sacrifising the execution speed.

LabVIEW VIs are modular in design. Any VI can run by itself or can be used as a part of
another VI. The programmer is given the opportunity to create their own icons for their
VIs. This allows the user to design a hierarchy of VIs and subVIs that can be modified,
interchanged and combined with other VIs to meet application needs.

The execution of order in LabVIEW is determined by the flow of data between blocks,
and not sequential lines of text. This property of LabVIEW enables creation of diagrams
in G that have simultaneous operations. Consequently multitasking, running multiple
execution threads and multiple VIs is very straightforward in LabVIEW.

LabVIEW does not allow syntax errors in block diagrams. In the case of wiring two
terminals with different types, LabVIEW refuses to wire them together and displays a
broken wire. These wires are called bad wires and all the bad wires can be removed by a
command named remove bad wires. This feature of showing the syntax errors at the very
instance that they are made is very helpful in identifying syntax errors and dealing with
them quickly. Most compilers point out the syntax errors at compile time. This can have
an avalanche affect on the errors that are produced. LabVIEW pointing out syntax errors
at the instance they are made tends to reduce errors that are made in programming.

The LabVIEW feedback of the errors is very helpful in identifying the syntax errors. The
run icon of the VI is disabled till the block diagram of the VI is syntactically correct. The
syntactic errors that have been made can be found by clicking on the run button. The feed
back also provides the option of locating the position of the error in the block diagram.

LabVIEW consists of a number of utilities for debugging. Features such as execution

highlighting and stepping over single instructions are very useful in debugging. These
features help the programmer to identify the run time errors of the program with less
time. The values created during execution that are travelling through the wires are popped
up on the wire, which increases the ability to identify errors quickly.

LabVIEW online help feature is very impressive. The entry for a specific function can be
found instantly and in other cases a search can be performed. It also consists of activities
that can be performed to learn LabVIEW. LabVIEW also consists of a tutorial that
outlines the basic features of it for first time users.

6.2 Negative features

The graphical programming language uses wires to show data flows between two nodes.
Since variables are allowed to be used in the diagram the understandability of the block
diagram may be sacrificed. Even thought it can be argued that variables decrease the
complexity of the diagram, ammeter programmers might use them for non-crucial
situations due to their ignorance. As the system is designed to cater for ammeters, having
the option of adding variables may reduce the readability of programs.

20
Every time a local or global variable is created a copy of the original value is made and
kept in memory. Even though this might not affect modern large memories, it is
noticeable when copies of arrays or clusters are created. It is also noted by Socratis
Kalogrianitis, that using variables can slow down the program by up to 140% according
tests [6].

Even thought the graphical language is simple, writing programs to perform advanced
functions can get tedious. Every time a new subVI is created a new window appears. In
the case of large programs where many subVIs should be written, this could be drawback
of the system.

As a simulation tool LabVIEW does not have functions that facilitate animation of front
panel objects. The lack of functions that can perform animation limits the capabilities of
LabVIEW.

Recursion cannot be performed in LabVIEW. This is a limitation in LabVIEW. Some

algorithm techniques such as divide and conquer can not be implemented in LabVIEW.

Another drawback of the system is National Instruments have included a vast variety of
virtual instruments in various libraries and beginners learning the system would have
troubles with mastering the system. Being a very powerful system obtaining the full
capabilities of it would require extensive exploration.

21
7. References
[1] Basic concepts of LabVIEW 4, Leonard Sokoloff, Prentice Hall, 1998.

[2] LabVIEW 3.1, Charles seiter. MacWorld, Nov 1995

[3] LabVIEW 4.0, Charles seiter. MacWorld, Aug 1996

[4] abVIEW for everyone : graphical programming made even easier, Lisa Wells and
Jeffrey Travis, Prentice Hall PTR, 1997

[5] National Instruments, http://www.natinst.com

[6] Local variables: Blessing or Pandora’s box, Socratis Kalogrianitis

http://vaneg1.ecs.umass.edu/Socratis/LabVIEW/Articles/Locals

[7] What is LabVIEW software? VERTREX Electronic Systems, inc.

http://www.vektrex.com/what_is_labview.html

22