You are on page 1of 33

LabVIEW for Physicists

Ben Jeffery
24th October 2002

What is it?
Laboratory Virtual Instrument Engineering
Development environment for the G
Produced by National Instruments for
all major operating systems.
Originally developed for communication
with lab devices.
A really useful tool.

Why use LabVIEW?

Easy to Learn - Intuitive.
Easy to Use.
No Syntax.
Source code reads like schematic.
Speed of development.
Ready made controls for many instruments.
Easy and instant debugging.
Power Instant Parallel threads.
No memory concerns. (Within Reason)
As versatile as text-based languages.
Fun. Honest!

Cost 1000 minimum.
Hard to master advanced techniques.
Code can become an impenetrable mess if
youre not careful!
Creating highly customized applications can
become time consuming.

The Language
Building an application
Front Panel
Source Diagram
Built-in Functions
User Vis

The G Language:
Completely graphical programming language.
Source code is a diagram of nodes and wires.

Data travels along wires.

Flow of data controls execution. Not flow of code!
Position on diagram is irrelevant.
Being an expert in C can be a disadvantage

A New Way of Thinking:

Dataflow NOT


Guiding Principle:
A node does not run until
data sits at all its wired inputs.
Data Dependency

Building an Application:
Applications are called virtual instruments (VIs)
Two parts to make:
1. Front Panel
2. Source Diagram
Always start with the front panel.
Draw a pencil block diagram of the main
functions of the diagram.
Make this diagram in G code.

The Front Panel:

How the user interacts with G.
Contains both controls and indicators.
Each item on the front panel has a
corresponding node on the source diagram.
Many ready made controls means quick and
easy construction of simple front panels.
There is scope for customisation of the controls
but this is mainly cosmetic.

Controls and Indicators:

Front panel objects are either
controls or indicators.
The corresponding nodes are
identified as shown.

Controls are sources for data

Indicators are sinks for data
Constants are sources for data
that do not appear on the front




Making the Front Panel:

The best way to show this is in LabVIEW:
Use tab controls instead of cluttering the panel.
Set limits on data entry to save programmatic
Keep to a consistent style.
Dont go wild with the colours.
Add text boxes when explanation is needed.
Use schematic representation if a physical
system is involved.
Remember someone else might need to
understand it in your absence!

Building the diagram:

Double clicking any control on the front panel

will take you to its node on the source diagram
and vice-versa.
Clicking window, show diagram (Ctrl-E) will
also display the source diagram.

Building the diagram:

Nodes are placed in a similar way to controls on
the front panel.
An extra tool is used on the source diagram:

The Wiring Tool:

The most used, and most infuriating tool in
Avoid crossing wires.
Click to join nodes together:

Types of Node:
Types of nodes:
Indicators and Controls
Built in Functions
User VIs (sub-routines)

All have one or more terminals that usually only

accept one data type.

Types of Wire:
As terminals accept only defined data
types, so wires have defined types.
This is indicated by colour and style.
Usual data types:
8,16,32 bit Integers (Signed and Unsigned)
Single, Double and Extended floating point
Clusters (Combination of any above)

Program Control:
Run Once: Program executes until
all data is sunk.
Run Continuously:
Run Once occurs
Abort Execution:
Immediate halt.
Pause Execution:
Useful for debugging.

Lets see some LabVIEW

Well start with a simple example to get a feel
for programming in LabVIEW:

A Closer Look
Weve covered most of the basics of the
environment. Now lets look at methods and
techniques of programming.
Built In Functions
User Vis
Programming Tips

How you control data flow
Case Structure
While Loop (with shift registers)
For Loop
Formula Node
Events Structure
Understanding the operation of these is vital.


Similar to the Case statement in C

Contains one or more frames.
The frame that executes depends on what is
wired to the selection terminal.
Many data types can be wired to the selector.
Lets see it in LabVIEW:


Similar to the While statement in C

Contains one frame that is repeated
Test for continuance is performed after
execution so frame always executes once.
i terminal gives number of current iteration
(first frame is 0)
stop terminal can be continue if true or stop
if true selected from context menu.

Shift Registers:

Selected via right-clicking the frame.

Enables the result of an iteration to be passed to
the next iteration.
Can be used for any data type
The results of older iterations can be accessed
by making the left terminal larger.
The initial value is set by wiring to the left
terminal and the final iterations value is output at
the right terminal.
Results are kept between runs of a vi.

For Loop:

Similar to the while loop but is executed a set

number of times (wired to the N terminal)
If 0 is wired to the terminal the frame does not
run, do outputs will be invalid.
Input arrays can be indexed automatically and if
N is not wired the number of iterations will be the
size of the largest input array.
Shift registers can also be used here.


Used to order events where no data dependency

Can have more than one frame but this should
ALWAYS be avoided. (Like goto in C)

Formula Node:

Used to avoid large numbers of arithmetic

Has one or more inputs and outputs
Uses C type syntax

Event Structure:

Handles windows events

Used for customisation of user interface
Allows very fancy tricks!
LabVIEW 6.1 only

Built in Functions:
Over 100 built in functions

Use the context help window to find what you


Built in Functions:
Low Level
Boolean Logic
These functions accept different data types and
often arrays can be directly wired.
Mid Level
Array Manipulation (Transpose, interpolate,
String Manipulation (Search, format,
Time and Date

Built in Functions:
High Level
File I/O
Device communication (GPIB, serial etc)
Network communication (TCP, UDP, IrDA)
Waveform manipulation (FFT, Filters,
Sound and Graphics
Program Control
Advanced: Semaphores, Queues,
So check before you build your own

User Vis:
For often used routines or to prevent an excess of
code on your diagram create a user vi
Create the vi as if it were a stand alone program
Right click the icon to access the wiring and icon
Show connector and select a pattern of
terminals and then use the wiring tool to select
controls and indicators to be terminals.
Edit the icon
Place the vi where you need it using select a vi
off the function pallet.
Lets see that in LabVIEW:

Collection of one or more items of data
Best used as Named Clusters

In this way you can carry related data in one

wire and extract only the data you need when
you need it.
Also reduces the need for many terminals in a
user vi.

The Error Cluster:

LabVIEW standard, used in many built in VIs

Passed along to each vi. If status is true the vi

does not run as the preceding one gave an error.
Lets illustrate this with an example:

Programming Tips:
Use a left to right layout
Use named clusters for both neatness and ease
of variable selection.
If functions need to happen in a sequence
establish a data dependency, so that the
functions are connected in a chain.
This is easily done using the error cluster.
Remember that functions not connected and in
the same frame will run in parallel.
Make user VIs so that your code is modular.