1 INTRODUCTION

LabVIEW (short for Laboratory Virtual Instrumentation Engineering Workbench) is

a platform and development environment for a visual programming language from National
Instruments. The graphical language is named "G". Originally released for the Apple
Macintosh in 1986, LabVIEW is commonly used for data acquisition, instrument control, and
industrial automation on a variety of platforms including Microsoft Windows, various flavors
of UNIX, Linux, and Mac OS X. The latest version of LabVIEW is version LabVIEW 2011.
Visit National Instruments at www.ni.com.
The code files have the extension “.vi”, which is an abbreviation for “Virtual
Instrument”.
LabVIEW offers lots of additional Add--‐Ons and Toolkits.

1.1 Dataflow Programming:

The programming language used in LabVIEW, also referred to as G, is a dataflow

programming language. Execution is determined by the structure of a graphical block diagram
(the LV--‐source code) on which the programmer connects different function--‐nodes by
drawing wires. These wires propagate variables and any node can execute as soon as all its
input data become available. Since this might be the case for multiple nodes simultaneously,
G is inherently capable of parallel execution. Multi--‐processing and multi--‐threading
hardware is automatically exploited by the built--‐in scheduler, which multiplexes multiple
OS threads over the nodes ready for execute. the graphical approach also allows non--‐
programmers to build programs simply by dragging and dropping virtual representations of
lab equipment with which they are already familiar. The LabVIEW programming
environment, with the included examples and the documentation, makes it simple to create
small applications. This is a benefit on one side, but there is also a certain danger of
underestimating the expertise needed for good quality "G" programming. For complex
algorithms or large--‐scale code, it is important that the programmer possess an extensive
knowledge of the special LabVIEW syntax and the topology of its memory management.
The most advanced LabVIEW development systems offer the possibility of building
stand--‐alone applications

1
1.2 Benefits:

One benefit of LabVIEW over other development environments is the extensive

support for accessing instrumentation hardware. Drivers and abstraction layers for many
different types of instruments and buses are included or are available for inclusion. These
present themselves as graphical nodes. The abstraction layers offer standard software
interfaces to communicate with hardware devices. The provided driver interfaces save
program development time. The sales pitch of National Instruments is, therefore, that even
people with limited coding experience can write programs and deploy test solutions in a
reduced time frame when compared to more conventional or competing systems. A new
hardware driver topology (DAQmxBase), which consists mainly of G--‐coded components
with only a few register calls through NI Measurement Hardware DDK (Driver Development
Kit) functions, provides platform independent hardware access to numerous data acquisition
and instrumentation devices. The DAQmxBase driver is available for LabVIEW on Windows,
Mac OS X and Linux platforms.
This document introducing the following themes:
 Start using LabVIEW

 The LabVIEW Environment

 Front Panel and Block Diagram

 Palettes: Control Palette, Functions Palette, Tools Palette

 Data Types

 Property Nodes

 Sub VIs

 Loops and Structures

 Troubleshooting and Debugging

 Working with data

 Arrays

 Array Functions

 Cluster

 Working with Strings

 Error Handling

2
 Working with Projects using Project Explorer

 Design Techniques

 Shift Register

 State Machine

 Multiple Loops

 User Interface

 Plotting Data

 Deployment: Building Executable Applications (.exe)

 Introduction to Add Ons and Toolkits

 Briefly explanations…

 More detail about Control and Simulation Toolkit in later chapter

 Introduction to DAQ --‐ Data Acquisition

 MAX – Measurement and Automation Explore

 NI--‐DAQmx

 Quick Reference with Keyboard Short--‐cuts

3
2 START USING LABVIEW

This chapter explains the basic concepts in LabVIEW.

2.1 The LabVIEW Environment:

LabVIEW programs are called Virtual Instruments, or VIs, because their appearance and
operation imitate physical instruments, such as oscilloscopes and multimeters. LabVIEW
contains a comprehensive set of tools for acquiring analyzing, displaying, and storing data, as
well as tools to help you troubleshoot your code.
When opening LabVIEW, you first come to the “Getting Started” window.

In order to create a new VI, select “Blank VI” or in order to create a new LabVIEW
project, select “Empty project”.
When you open a blank VI, an untitled front panel window appears. This window
displays the front panel and is one of the two LabVIEW windows you use to build a VI. The
other window contains the block diagram. The sections below describe the front panel and the
block diagram.
2.2 Front Panel:

When you have created a new VI or selected an existing VI, the Front Panel and the Block
Diagram for that specific VI will appear.

4
 In LabVIEW, you build a user interface, or front panel, with controls and indicators.
Controls are knobs, push buttons, dials, and other input devices. Indicators are graphs, LEDs,
and other displays.
You build the front panel with controls and indicators, which are the interactive input
and output terminals of the VI, respectively. Controls are knobs, push buttons, dials, and other
input devices. Indicators are graphs, LEDs, and other displays. Controls simulate instrument
input devices and supply data to the block diagram of the VI. Indicators simulate instrument
output devices and display data the block diagram acquires or generates.
E.g., a “Numeric” can either be a “Numeric Control” or a “Numeric Indicator”, as seen
below.

If you select a “Numeric Control”, it can easy be changed to an “Numeric Indicator” by right
click on the object an select “Change to Indicator”

5
Or opposite, I you select a “Numeric Indicator”, it can easy be changed to an “Numeric
Control” by right click on the object an select “Change to Control”

The difference between a “Numeric Control” and a “Numeric Indicator” is that for a
“Numeric Control” you may enter a value, while the “Numeric Indicator” is read--‐only, i.e.,
you may only read the value, not change it.

The appearance is also slightly different, the “Numeric Control” has an increment and
an decrement button in front, while the “Numeric Indicator” has a darker background color in
order to indicate that its read--‐only.

2.3 Block Diagram

After you build the user interface, you add code using VIs and structures to control the
front panel objects. The block diagram contains this code. In some ways, the block diagram
resembles a flowchart.
After you build the front panel, you add code using graphical representations of
functions to control the front panel objects. The block diagram contains this graphical source
code. Front panel objects appear as terminals, on the block diagram. Block diagram objects

6
include terminals, subVIs, functions, constants, structures, and wires, which transfer data
among other block diagram objects.
The Figure below shows a front panel and its corresponding block diagram with front
panel and block diagram components.

7
The different components are as follows:

 Toolbar
 Owned Label
 Numeric Control
 Free Label
 Numeric Control Terminal
 Knob Terminal
 Numeric Constant
 Multiply Function
 Icon
 Knob Control
 Plot Legend
 XY Graph
 Wire Data Path
 XY Graph Terminal
 Bundle Function
 SubVI
 For Loop Structure

2.4 Controls Palette

The Controls and Functions palettes contain sub palettes of objects you can use to
create a VI. When you click a sub palette icon, the entire palette changes to the sub palette

8
you selected. To use an object on the palettes, click the object and place it on the front panel
or block diagram. The Controls palette is available only on the front panel. The Controls
palette contains the controls and indicators you use to build the front panel.
The most used Sub Palettes are the Numeric Sub Palette, the Boolean Sub Palette and
the String & Path Sub Palette.
You may change the appearance and the contents of the Controls palette:
You may Pin the palette, so it is always visible, just click the little pin button in the
upper left corner of the palette:

If you want to change the content and appearance of the palette, click the “View” button.

Here you may change the way the palette should look.

If you click “Change Visible Categories…” you may change which Categories you
want to have visible.

9
2.4.1 Numeric Sub Palette

“Numerical Control” and “Numerical Indicator” are the most used objects in the numeric sub
palette.

10
2.4.2 Boolean Sub Palette
This palette has lots of different buttons you may use. OK, Cancel and Stop buttons are
useful.

2.4.3 String & Path Sub Palette

In the String and Path palette we have String Controls, Combo Box, etc.

2.5 Function Palette

The Functions palette is available only on the block diagram. The Functions palette contains
the VIs and functions you use to build the block diagram.

11
2.6 Tools Palette
You can create, modify, and debug VIs using the tools located on the floating Tools
palette. The Tools palette is available on both the front panel and the block diagram. A tool is
a special operating mode of the mouse cursor. The cursor corresponds to the icon of the tool
selected in the Tools palette. Use the tools to operate and modify front panel and block
diagram objects.

12
The Tools palette is available from the View menu:

If you make sure “Automatic wiring” is disabled (I recommend you do so!) you
may use the Tab key on your keyboard in order to switch between the most common tools.
The most used tools are:

Use the Operating tool, shown at left, to change the values of a control or select the text
within a control. The Operating tool changes to the icon shown at left when it moves over a
text control, such as a numeric or string control.
Use the Positioning tool, shown at left, to select, move, or resize objects. The
Positioning tool changes to resizing handles when it moves over the edge of a resizable
object.
Use the Labeling tool, shown at left, to edit text and create free labels. The
Labeling tool changes to the following icon when you create free labels.
Use the Wiring tool, shown at left, to wire objects together on the block diagram.
2.7 Wiring
In order to create the logical flow between the object on the Block Diagram, you need
to use the Wiring tool in order to connect the different objects together.
Use the Wiring tool to wire objects together on the block diagram.
Available Keyboard Shortcuts when dealing with Wiring:

13
 Ctrl--‐B is very useful. This short--‐cut removes all broken wires on the Block Diagram.
2.8 Toolbar
Below we see the LabVIEW Toolbar:

The behaviors of the different buttons are as follows:

Click the Run button to run a VI. LabVIEW compiles the VI, if necessary. You can run a
VI if the Run button appears as a solid white arrow. The solid white arrow, shown above, also
indicates you can use the VI as a subVI if you create a connector pane for the VI.

While the VI runs, the Run button appears as shown at left if the VI is a top--‐level VI,
meaning it has no callers and therefore is not a subVI.

If the VI that is running is a subVI, the Run button appears as shown at left.

The Run button appears broken, shown at left, when the VI you are creating or editing
contains errors. If the Run button still appears broken after you nish wiring the block
diagram, the VI is broken and cannot run. Click this button to display the Error list window,
which lists all errors and warnings.

Click the Run Continuously button, shown at left, to run the VI until you abort or pause
execution. You also can click the button again to disable continuous running.

14
 While the VI runs, the Abort Execution button, shown at left, appears. Click this button
to stop the VI immediately if there is no other way to stop the VI. If more than one running
top--‐level VI uses the VI, the button is dimmed.
Click the Pause button, shown at left, to pause a running VI. When you click the Pause
button, LabVIEW highlights on the block diagram the location where you paused execution, and
the Pause button appears red. Click the button again to continue running the VI.
2.9 Execution
In addition to the Toolbar buttons above the following Keyboard Shortcuts are available
when dealing with Execution:

2.10 The Objects short--‐cut menu

The most often--‐used menu is the object shortcut menu. All LabVIEW objects and empty space
on the front panel and block diagram have associated shortcut menus. Use the shortcut menu
items to change the look or behavior of front panel and block diagram objects. To access the
shortcut menu, right--‐click the object, front panel, or block diagram.
The Numeric control has the following short--‐cut/right--‐click menu:

15
The short--‐cut menu will be different for the different controls or objects.
2.11 Dataflow Programming
LabVIEW follows a dataflow model for running VIs. A block diagram node executes
when all its inputs are available. When a node completes execution, it supplies data to its
output terminals and passes the output data to the next node in the dataflow path.
Visual Basic, C++/C#, Java, and most other text--‐based programming languages
follow a control flow model of program execution. In control flow, the sequential order of
program elements determines the execution order of a program.
2.12 Help
The Context Help window (Ctrl +H) displays basic information about LabVIEW objects
when you move the cursor over each object. The Context Help window is visible by default.
To toggle display of the Context Help window, select Help--‐Show Context Help, press the
Ctrl--‐H keys, or click the Show Context Help Window button on the toolbar.
When you move the cursor over front panel and block diagram objects, the Context
Help window displays the icon for subVIs, functions, constants, controls, and indicators, with
wires attached to each terminal. When you move the cursor over dialog box options, the
Context Help window displays descriptions of those options. In the window, required
connections are bold, recommended connections are plain text, and optional connections are
dimmed or do not appear.
The Figure below shows an example of the Context Help window.

16
3 SUB VIS
This chapter explains the basic concepts of creating and using Sub VIs in LabVIEW.
When you place a VI on the block diagram, LabVIEW considers the VI to be a subVI.
When you double--‐click a subVI, its front panel and block diagram appear, rather than a
dialog box in which you can configure options. The front panel includes controls and
indicators. The block diagram includes wires, front panel icons, functions, possibly subVIs,
and other LabVIEW objects. The upper right corner of the front panel and block diagram
displays.
Below we see an example of a bad Block Diagram. This example does not make use
of the SubVI functionality in LabVIEW at all! This makes the Block diagram hard to read
and understand. The size of the diagram is also too large! The Block Diagram should always
fit into the screen. Both the Front Panel and the Block Diagram should fit into a screen
resolution of 1024x768.

With use of SubVIs, the example above could turn into, e.g.:

17
As you can see, much of the code in the Main VI have been replaced and put into SubVIs.

The program is now more readable.

Another approach is to use a so--‐called State Machine principle (more about this in chapter
11 --‐ Design Techniques ).

Available Keyboard Shortcuts when dealing with Sub Vis:

3.1 Create New Sub VI from Scratch

Select “Blank VI” in the “Getting Started” window when opening LabVIEW, or when
LabVIEW is already opened select File → New V” or use the short--‐cut Ctrl+N.

3.1.1 Input and Output SubVI Connectors

Most SubVIs will have input and output “connectors”. This is similar with functions or
methods in other programming language that have input arguments and an output/result.
In order to create connectors, Right--‐click on the icon in the upper right corner of the
VI and select “Show Connector”.

18
You may select different Patterns, i.e., how many input and output connectors you need.

Make sure you select a Pattern with enough connectors even if you don’t need all the
connectors at the moment. I recommend that you standardize on the pattern in the Figure
above.
Select the Wire tool and click on the wanted connector, then click on the Control or
Indicator on the Front Panel you want to connect to this connector.

You should always follow these connector rules:

 Upper left connector: “Reference” In

 Upper right connector: “Reference” Out
 Lower left connector: Error In Cluster
 Lower right connector: Error Out Cluster

3.1.2 Icon Editor

You should also create a suitable icon for your SubVI. In order to open the Icon Editor,
double--‐click on the icon in the upper right corner of your VI.

19
Below we see a block diagram with SubVIs icon appearance created with the Icon Editor.

3.2 Create Sub VI from existing code

If you find out that you code is getting messy, you could consider put some code into a
SubVI.
The procedure is as follows:
 Select the part of your code you want to turn into a SubVI
 From the Edit menu, select “Create SubVI”
 LabVIEW will automatically create a SubVI for the selected code.
 Clean up automatically created wires, etc.
 Create a suitable icon for your SubVI

20
 Although this is quite easy to do this, I do not recommend that you use this
functionality to much. This is because you should create and use SubVIs from the first
moment you start creating your application and not afterwards when you find out that you
have been creating a messy code.
So you should structure and design your code with the use of SubVIs from the
beginning!
3.3 Using Sub VIs
Below we see an example of how to use SubVIs in a program (Top VI or SubVIs):

You may open a SubVI from the File menu, select a SubVI from the Functions palette
or use drag and drop in different ways, e.g., you may drag a VI from the File Explorer in
Windows directly into an existing VI you have already opened in LabVIEW.

21
4 CUSTOMIZE LABVIEW
LabVIEW has lots of possibilities for customizing the appearance and the use of the
LabVIEW environment. Select “Options…” from the Tools menu.

The default settings is not necessary the best, here are some recommendations for setting up
the LabVIEW environment.

Block Diagram

22
Disable “Enable auto wiring” option. This prevents LabVIEW from automatically connecting
adjacent blocks. Although it seems useful to have auto wiring enables, it is my experience
that the auto wiring is a little annoying since it tends to draw wires between blocks when you
do not want any wire.
Disable “Place front panel elements as icons” option. This causes LabVIEW to use
small terminal icons on the block diagram. If you, instead, activate this option, the terminal
icons are larger, with a mimic of the element as it appears at the front panel.
Category: Controls/Functions Palettes
In the Format list: select “Category (Icons and Text)”
Category: Alignment Grid
Turn off “Show Front Panel Grid” and “Show Block Diagram Grid”.

23
5 LOOPS AND STRUCTURES
This chapter explains the basic concepts of Loops and Structures in LabVIEW.
The different Loops and Structures available are located in the “Structures” sub palette in the
Functions palette on the Block Diagram.

5.1. Loops
These loops will be explained in detail below.
5.1.1 For Loop
A For Loop executes a sub diagram a set number of times. The Figure below shows an empty
For Loop in LabVIEW.

A For loop executes its sub diagram n times, where n is the value wired to the count (
) terminal. The iteration ( ) terminal provides the current loop iteration count, which
ranges from 0 to n--‐1.
After you create a For Loop, you can use shift registers to pass values from one
iteration to the next. If you wire an array to a For Loop, you can read and process every

24
element in that array by enabling auto--‐indexing. You also can enable auto--‐indexing by
configuring a For Loop to return an array of every value generated by the loop.
You can add a conditional terminal to configure a For Loop to stop when a Boolean
condition or an error occurs. A For Loop with a conditional terminal executes until the condition
occurs or until all iterations complete, whichever happens first. To add a conditional terminal to a
For Loop, right--‐click the For Loop border and select Conditional Terminal from the shortcut
menu. You must wire the conditional terminal and either wire the count terminal or auto--‐index
an input array for the loop to execute and for the VI to run.
To convert a For Loop to a While Loop, right--‐click the For Loop and select Replace
with While Loop from the shortcut menu.
5.1.2 While Loop
A While loop repeats the sub diagram inside it until the conditional terminal, an input
terminal, receives a particular Boolean value. The Boolean value depends on the continuation
behavior of the While Loop. Right--‐click the conditional terminal and select Stop if True or
Continue if True from the shortcut menu. You also can wire an error cluster to the
conditional terminal, right--‐click the terminal, and select Stop on Error or Continue while
Error from the shortcut menu. The While Loop always executes at least once.
Below we see an empty While loop:

After you create a While Loop, you can use shift registers to pass values from one
iteration to the next. If you wire an array to a While Loop, you can read and process every
element in that array by enabling auto--‐indexing.
In order to convert a While Loop into a For Loop, right--‐click the While Loop and
select “Replace with For Loop” from the shortcut menu. To convert a While Loop into a
Timed Loop, right--‐click the While Loop and select “Replace with Timed Loop” from the
shortcut menu.
5.2 Structures
5.2.1 Case Structure
The Case Structure has one or more sub diagrams, or cases, exactly one of which executes
when the structure executes. The value wired to the selector terminal determines which case
to execute and can be Boolean, string, integer, or enumerated type. You may right--‐click the
structure border to add or delete cases. Use the Labeling tool to enter value(s) in the case
selector label and configure the value(s) handled by each case.
Below we see an empty Case structure:

25
 Below we see an example of a Case structure with 2 cases, a “True” case and a
“False” case. Depending of the Boolean input value, the Numeric1 and Numeric2 is either
Added or Subtracted.

5.2.2 Sequence Structure

A Sequence structure Consists of one or more sub diagrams, or frames, that execute
sequentially. Right--‐click the structure border to add and delete frames or to create sequence
locals to pass data between frames. Use the Stacked Sequence structure to ensure a sub
diagram executes before or after another sub diagram.
Below we see an empty Sequence structure.

Below we see an example where we use “Sequence Local”, i.e., we pass a value from one
sequence to the next.

26
5.2.3 Event Structure
An Event structure has one or more sub diagrams, or event cases, exactly one of
which executes when the structure executes. The Event structure waits until an event
happens, then executes the appropriate case to handle that event. Right--‐click the structure
border to add new event cases and configure which events to handle. Wire a value to the
Timeout terminal at the top left of the Event structure to specify the number of milliseconds
the Event structure should wait for an event to occur. The default is –1, indicating never to
time out.

27
6 TROUBLESHOOTING AND DEBUGGING
This chapter explains the basic concepts of troubleshooting and debugging in LabVIEW.
6.1 How to find errors
If a VI does not run, it is a broken, or “nonexecutable”, VI. The Run button often appears
broken, shown at left, when you create or edit a VI. If it is still broken when you finish wiring
the block diagram, the VI is broken and will not run. Generally, this means that a required
input is not wired, or a wire is broken.
Click the broken Run button to display the Error list window, which lists all the
errors. Double--‐click an error description to display the relevant block diagram or front panel
and highlight the object that contains the error.
6.2 Highlight Execution
View an animation of the execution of the block diagram by clicking the Highlight
Execution button. Execution highlighting shows the flow of data on the block diagram from
one node to another using bubbles that move along the wires. Note! Execution highlighting
greatly reduces the speed at which the VI runs.

6.3 Probes
Use the Probe tool to check intermediate values on a wire as a VI runs.
When execution pauses at a node because of single--‐stepping or a breakpoint, you
also can probe the wire that just executed to see the value that flowed through that wire. You
also can create a custom probe to specify which indicator you use to view the probed data.
For example, if you are viewing numeric data, you can choose to see that data in a chart
within the probe. To create a custom probe, right--‐click a wire and select Custom Probe--‐
New from the shortcut menu.

28
6.4 Breakpoints

Use the Breakpoint tool to place a breakpoint on a VI, node, or wire on the block
diagram and pause execution at that location. When you set a breakpoint on a wire, execution
pauses after data pass through the wire. Place a breakpoint on the block diagram workspace
to pause execution after all nodes on the block diagram execute. When a VI pauses at a
breakpoint, LabVIEW brings the block diagram to the front and uses a marquee to highlight
the node or wire that contains the breakpoint. LabVIEW highlights breakpoints with red
borders for nodes and block diagrams and red bullets for wires. When you move the cursor
over an existing breakpoint, the black area of the Breakpoint tool cursor appears white. Use
the Breakpoint tool to click an existing breakpoint to remove it.
You may also right--‐click on the wire in order to set a breakpoint or open the Breakpoint
Manager.

29
Breakpoint Manager is a tool for enable, disable and delete breakpoints.

6.5 Step into/over/out debugging

Available Keyboard Shortcuts when Debugging:

30
7 WORKING WITH DATA
This chapter explains the basic concepts of creating and using Sub Vis in LabVIEW.

7.1 Arrays
Arrays are very powerful to use in LabVIEW. In all your applications you would
probably use both One--‐Dimensional Arrays and Two--‐Dimensional Arrays.
7.1.1 Auto--‐Indexing
LabVIEW uses a powerful mechanism called “Auto--‐indexing”.
For Example you may use a For loop to create Array data like this:

Or you may use an Array like this in order to automatically specify number of iterations:

7.1.2 Array Functions

LabVIEW has lots of built--‐in functions for manipulating arrays.

31
 All these functions are basic (but very useful) array functions you will probably be
using in all your applications and VIs.
7.2 Cluster
Clusters group data elements of mixed types, such as a bundle of wires, as in a
telephone cable, where each wire in the cable represents a different element of the cluster. A
cluster is similar to a record or a struct in text--‐based programming languages. Bundling
several data elements into clusters eliminates wire clutter on the block diagram and reduces
the number of connector pane terminals that subVIs need. The connector pane has, at most,
28 terminals. If a front panel contains more than 28 controls and indicators that you want to
use programmatically, group some of them into a cluster and assign the cluster to a terminal
on the connector pane. Like an array, a cluster is either a control or an indicator. A cluster
cannot contain a mixture of controls and indicators.

Although cluster and array elements are both ordered, you must unbundle all cluster
elements at once rather than index one element at a time. You also can use the “Unbundle By
Name” function to access specific cluster elements.
7.2.1 Cluster Order
You may sort the different elements in the cluster by right--‐click on the cluster
border and select “Reorder Controls in Cluster…”

32
7.2.2 Cluster Elements
In order to manipulate and work with cluster LabVIEW offers lots of functions, such as the
“Bundle” and “Unbundle” functions.

In order to write to a cluster from the code, you may use the “Bundle” function or the
“Bundle By Name” function. See example below:

33
8 WORKING WITH STRINGS
Working and manipulating with strings is an important part in LabVIEW development.
On the Front panel we have the following String controls and indicators available from the
Control palette:

On the Block Diagram we have the following String functions available from the Functions
palette:

Some of the most important String functions are:

Concatenate Strings

34
This function concatenates several strings into on string:

Search and Replace String

Use this when you want to replace or remove a certain text in a string.

Match Pattern

This is the most useful function when it comes to string manipulation.

Format Into String

35
9 ERROR HANDLING
This chapter explains the basic concepts of handle errors in your code.

9.1 Finding Error

If a VI does not run, it is a broken, or “nonexecutable”, VI. The Run button often appears
broken, shown at left, when you create or edit a VI. If it is still broken when you finish wiring
the block diagram, the VI is broken and will not run. Generally, this means that a required
input is not wired, or a wire is broken. Click the broken Run button to display the Error list
window, which lists all the errors. Double--‐click an error description to display the relevant
block diagram or front panel and highlight the object that contains the error.
9.2 Error Wiring
Error handling is important in all programming languages. LabVIEW has powerful
mechanism for handling errors and error wiring.
You should always wire the Error cluster between all SubVIs, nodes, etc. that support this,
see example below.

The Error cluster is located in the Controls palette here:

The Error Cluster:

36
The Error cluster contains of the following parts:

 Status – True/False. False: No Error, True: Error

 Code – Error Code
 Source – Textual Error message
9.3 Error Handling in SubVIs
When creating SubVIs you should always create an Error In and an Error Out. In the
SubVI code you should also use a Case structure and wire the Error in cluster to the Case
Selector as shown below.

9.4 Error Handling

LabVIEW has several useful SubVIs, etc for Error Handling:

37
These are:

In general you should always show the error to the user. See LabVIEW Help for more details
of how to use these SubVIs.

38
10 WORKING WITH PROJECTS
This chapter explains the basic concepts of the project Explorer in LabVIEW.
10.1 Project Explorer
It is not necessary to use the Project Explorer when developing your LabVIEW code,
but it is an easy way to structure your code, especially for larger projects.

The project Explorer is necessary when you want to deploy your code into, e.g., an
executable (.exe) application, build a setup, etc.
The Project Explorer is also very useful when you integrate a source control tool, such as
Team Foundation Server, Visual Source Safe, etc. Then you may easily check files in and out
of the source code system.
In order to create a new Project in LabVIEW, simply select “Empty Project” from the
Getting Started window when you open LabVIEW.

39
10.2 Deployment
When your application is finished, you may want to distribute or deploy your application and
share it with others.

The Project Explorer gives you several choices when it comes to distribute and deploy your
application. Some of the options are:
Create an executable application (.exe) – this means that the target doesn’t need to
have LabVIEW installed on their computer. All the target need is LabVIEW Run--‐Rime,
which is a small installation package.
You may create your own installer, so all the target need is to run a setup.exe in order
to use your application
Other possibilities is to create a Web Service or a Shared Library (DLL) of your
application
All these options are available from the Project Explorer, just right--‐click on your
“Build Specifications” node.

We will go through how we create an executable application. Click Build

Specifications→New→Application (EXE).

In the Properties window fill in your name of the application.

40
Make sure you select a Startup VI.

There are lots of properties and setting you may use in order to create your
application, go through all the Categories in the Properties window.
When you have finished all the steps, just select “Build” in order to create your
application.

When you make changes in your application, it is easy to rebuild your application:

41
42
11 DESIGN TECHNIQUES
This chapter explains some useful techniques to use when creating your application.

11.1 Force Program Flow

As mentioned earlier, LabVIEW follows a dataflow model for running VIs. A block
diagram node executes when all its inputs are available. When a node completes execution, it
supplies data to its output terminals and passes the output data to the next node in the
dataflow path.
In the example below we cannot be sure that the DAQmx Write.vi executes before the
DAQmx Stop Task.vi executes. LabVIEW will in this case randomly execute one of these
first. If the Stop VI happens to execute first then the Write VI will failed because task has
been stopped.

11.2 Shift Register

Use shift registers on For Loops and While Loops to transfer values from one loop
iteration to the next. Shift registers are similar to static variables in text--‐based programming
languages. A shift register appears as a pair of terminals, directly opposite each other on the
vertical sides of the loop border. The right terminal contains an up arrow and stores data on
the completion of an iteration. LabVIEW transfers the data connected to the right side of the
register to the next iteration. Create a shift register by right--‐clicking the left or right border
of a loop and selecting Add Shift Register from the shortcut menu.
A shift register transfers any data type and automatically changes to the data type of
the first object wired to the shift register. The data you wire to the terminals of each shift
register must be the same type.
To initialize a shift register, wire any value from outside the loop to the left terminal. If
you do not initialize the shift register, the loop uses the value written to the shift register when the
loop last executed or the default value for the data type if the loop has never executed.
Use a loop with an uninitialized shift register to run a VI repeatedly so that each time
the VI runs, the initial output of the shift register is the last value from the previous
execution. Use an uninitialized shift register to preserve state information between
subsequent executions of a VI. After the loop executes, the last value stored in the shift
register remains at the right terminal. If you wire the right terminal outside the loop, the wire
transfers the last value stored in the shift register. You can add more than one shift register to

43
a loop. If you have multiple operations within a loop, use multiple shift registers to store the
data values from those different processes in the structure.

11.3 State Programming Architecture

Creating VIs using the State Machine approach is very useful when creating (large)
applications.
In general, a state machine is a model of behavior composed of a finite number of
states, transitions between those states, and actions. It is similar to a "flow graph" where we
can inspect the way in which the logic runs when certain conditions are met.

Sometimes, you may want to change the order of the sequence, repeat one item in the
sequence more often than the other items, stop a sequence immediately, or have items in the
sequence that may execute only when certain conditions are met. Although your program
may not have any such requirements, there is always the possibility that the program must be
modified in the future. Therefore, a state programming architecture is a good choice, even if a
sequential programming structure is sufficient. The following list
describes more complex programming requirements that justify the use of a state
programming architecture for an application.
You need to change the order of the sequence
You must repeat an item in the sequence more often than other items

44
 You want some items in the sequence to execute only when certain conditions are
met.
The State Machine approach in LabVIEW uses a Case structure inside a While loop to
handle the different states in the program, and the transitions between them. The Shift
Register is used to save data from and between the different states.
Below we see examples of a state machine principle implemented in LabVIEW.
Simple State Machine principle

State Machine with multiple transitions depending on the State:

More advanced State Machine using Shift Registers:

45
11.4 Multiple Loops/Parallel programming
Often, you need to program multiple tasks so that they execute at the same time. In
LabVIEW tasks can run in parallel if they do not have a data dependency between them, and
if they are not using the same shared resource. An example of a shared resource is a file, or
an instrument.

Using multiple While loops is sometimes useful in applications that need to handle User
interactions in parallel with, e.g., DAQ operations, etc.
Below we see an example of how this structure could look like. The upper loop could handle
interaction with the user, while the lower loop could handle DAQ operations, such as reading
and writing to some I/O equipments.

46
 In order to pass data between the loops, you may e.g. use local variables. The loop
may have different time cycles. The I/O may require faster cycles than the User interaction
loop.
11.5 Templates
You should create your own templates for such VI you use a lot. It is easy to create
your own templates for scratch, just create a VI as you normally do and then save it as a
template with the ending “.vit”. You may also convert a VI you already made just by
changing the extension to “.vit”.
You should copy your templates to the LabVIEW template folder which is default
located in “C:\Program Files\National Instruments\LabVIEW X.X\Templates\”.

The Templates will then be available from the Getting Started Window or File→New… in
LabVIEW.
I may case I have created a sub folder called “My Templates” where I place all my templates.

47
12 USER INTERFACE
This chapter explains the basic concepts of creating user--‐friendly Graphical User Interfaces
(GUI) in LabVIEW.
Below we see a Front Panel (GUI) with a “poor” design.

The information (Controls and Indicators) on the Front Panel is not structured. You
should group elements that naturally belong together and use different colors with care.
When creating Graphical User Interfaces (GUI) you should use the controls from the
System palette and not from the Modern or Classic palettes. Modern Controls may be used in
Sub Vis with no visible User Interface (for the user).

48
12.1 VI Properties
In order to make the appearance of the Window that hosts your application, you
should always make some changes in the “VI Properties”.
You find the “VI Properties” by right--‐click on the icon in the upper right corner of your VI.

The first thing you should change is the “Window title”. Here you may type appropriate name
of your application or SubVI.

The next you should do is to the “Customize” button in order to customize the Window
appearance.

49
Below we see an application with a simple and neat User Interface and with a Customized
Windows appearance.

Below we see a professional application created in LabVIEW that implement common GUI
objects such as a Toolbar, a Tree view, a List view, etc.

50
13 PLOTTING DATA
This chapter explains the basic concepts when plotting data in LabVIEW.

LabVIEW offers powerful functionality for plotting data. In the Graph palette we have lots of
useful controls for plotting and visualization of data.

The most useful are:

Waveform Chart

Waveform Graph

XY Graph
13.1 Customizing

The different Chart components in LabVIEW offer a great deal of customizing.

You may click on the “Plot Legend” in order to set colors, different line
styles, etc.

51
If you right--‐click on the Graph/Chart, you may set properties such as auto--‐scaling, etc.

If you select Properties, you get the following dialog:

52
You may also select which items that should be visible or not.

The “Graph Palette” lets you zoom in and out on the Graph, etc.

 What is a Computer’s Role in SDR?

A software defined radio system is a radio communication system in
which certain hardware components are implemented in software. These
hardware components include filters, amplifiers, modulators, and
demodulators. Because these components are defined in software, you can
adjust a software defined radio system as needed
without making significant hardware changes. Since computers today may contain very fast
processors and high-speed interfaces, we can leverage these abilities for our software defined
radio by implementing them on a computer quickly, using LabVIEW.
Driver Software
Driver software provides application software the ability to interact with a device. It
simplifies communication with the device by abstracting low-level hardware commands and
register-level programming. Typically, driver software exposes an application programming
interface (API) that is used within a programming environment to build application software.
Application Software
Application software facilitates the interaction between the computer and user for
acquiring, analyzing, processing, and presenting measurement data. It is either a prebuilt
application with predefined functionality, or a programming environment for building
applications with custom functionality. Custom applications are often used to automate
multiple functions of a device, perform signalprocessing algorithms, and display custom user
interfaces.

53
 The NI-USRP driver currently supports the National Instruments’ LabVIEW
graphical development environment software for rapidly developing custom applications.
For more information, navigate to ni.com and search for “Out-of-the-Box Video with NI
USRP.” If you are viewing this digitally, click here to access this Developer Zone tutorial
directly.

54
14. FINDING HARDWARE & INSTALLING SOFTWARE
It is first important to understand the complexities and requirements of your
application to ensure that your wireless signal system is the right fit.
Identifying the Right Hardware
To help you identify the right hardware for your system, first navigate to ni.com/sdr.
At this portal you will find everything that you need to know about the USRP. You can use
the left-hand navigation facets to begin your search and narrow in on the right selection.
Finding the Specifications Online
The most important document for any device is the specifications document. This
document is housed on the product page for each device. Once you know the device of
interest, it is easiest to find the device using the search box in the upper right hand corner of
the ni.com website. Simply enter the product model number (i.e., 2920) and click search. An
example search query is shown on the next page, with the product page result outlined in red.
NI USRP Online Community
This ni.com community is the home for example VIs associated with the NI USRP,
"Universal Software Radio Peripheral." Browse to find a starting point, or post your own NI-
USRP-based examples.
Navigate to ni.com/sdr and click the Code Sharing Community image.
Purchasing Hardware
To receive a quote for NI USRP Hardware, you can add the hardware to your cart at
ni.com from the product page for the product. You can also call your NI Sales Engineer to
help design the best system for your application.
To speak with a technical representative, navigate to ni.com and click on the Contact Us link
on the homepage.
Installing Software
To acquire data from the USRP, you will need to first install a software development
environment and then the hardware driver.
Development Environment: LabVIEW Communications System Design Software
The development environment facilitates the interaction between the computer and user for
acquiring, processing, analyzing, and presenting measurement data. It is either a prebuilt
application with predefined functionality, or a programming environment for building
applications with custom functionality. Custom applications are often used to automate
multiple functions of a device, perform signal-processing algorithms, and display custom user
interfaces.
The primary development environment for NI-USRP is LabVIEW. LabVIEW is a
graphical programming language that abstracts the low-level complexities of text-based
programming into a visual language that scientists and engineers use worldwide to acquire,
analyze, process, and present data in the same environment.
Visit ni.com/labview-communications for more information and to download an evaluation.
Hardware Driver: NI-USRP
Driver software provides application software the ability to interact with a device. It
simplifies communication with the device by abstracting low-level hardware commands and

55
register-level programming. Typically, driver software exposes an application-programming
interface (API) that is used within a programming environment to build application software.
The hardware driver for the USRP is NI-USRP. The USRP driver comes with
example LabVIEW programs and help files to get you started.

56
15. NI-USRP LABVIEW DRIVER
When installed the NI USRP hardware driver automatically installs example
programs, help files, and functions.
 NI-USRP Example Programs
To locate example files for using the USRP driver in LabVIEW, navigate to the
Examples » Hardware Input and Output » NI USRP Host.
 NI-USRP Help Files
There are two forms of help offered within the LabVIEW development environment:
Context Help and Detailed Help:
Context Help:
The context help window displays basic information about LabVIEW objects when
you move the cursor over each object. To toggle the display of the context help window,
select View » Show Context Help or press <Ctrl-H>.
When you move the cursor over front panel and block diagram objects, the context
help window displays the icon for subVIs, functions, constants, controls, and indicators, with
wires attached to each terminal. When you move the cursor over dialog box options, the
context help window displays descriptions of those options.

LabVIEW Context Help

If a corresponding online help topic exists for an object that the context help window
describes, a blue More Help link appears in the context help window (Figure 5). Click the
link or the button to display the online help for more information about the object.

57
Detailed LabVIEW Help

NI-USRP Functions Palette

To access the NI-USRP functions in LabVIEW, navigate to the block diagram, then navigate
to Hardware Interfaces » NI-USRP. The functions will appear similar to the palette below.
Drag and drop a function onto the block diagram to begin programming.

. NI-USRP Palette in LabVIEW

NI-USRP Property Node

Use the niUSRP properties to access advanced configuration options for NI-USRP driver
applications.

. NI-USRP Property Node

The Eight Most-Used NI-USRP Functions
The following section outlines the eight most-used USRP functions to help get you
started with your experiments. They have been grouped in categories by their functionality.

58
These categories are: Configure, Read/Write, and Close. These categories are included in
most data acquisition programs and are important programming models to consider when
creating a new LabVIEW Virtual Instrument (VI).

NI-USRP Read and Write Data Types :

There are several instances of Write Tx Data and Fetch Rx Data VIs to choose from
for your convenience. The table below represents the options available instances.

59
Fetch and Write Type Description
Complex Double Cluster

Fetches a cluster of complex, double-precision floating-point

data from the specified channel. Modulation Toolkit VIs use the
complex, double-precision floating-point cluster data type. Use
this VI in applications that use Modulation Toolkit VIs.
Complex Double Waveform
Data

Fetches complex, double-precision floating-point data in a

waveform data type from the specified channel.

Complex Double

Fetches complex, double-precision floating-point data from the

specified channel.

16-bit Integer

Fetches complex, 16-bit signed integer data from the specified

channel. To use this VI, you must set the Host Data Type
property to I16.

2D Array Complex Double

Fetches complex, double-precision floating-point data from

multiple channels.

2D Array 16-bit Integer

Fetches complex, 16-bit signed integer data from multiple

channels. To use this VI, you must set the Host Data Type
property to I16.

60
16. EXAMPLE
Digital Communications

Goals :
Open and run a digital communications example
Identify the parts of the block diagram and elements of the modulation/demodulation
process

Part A : 1. Pair up with the person or group next to you to find out who will open the transmit VI
and who will open the receive VI

In the Exercises folder, open either the USRP Packet Receiver or the USRP
Packet Transmitter VI

Configure the transmitter

Switch to the Tx Parameters tab
Ensure the IQ Sampling Rate and Frequency are the same as the receiver
Switch to the Specify Modulation tab
Ensure the same modulation scheme is used for reception
Switch to the Specify Packet tab
Ensure the packet structure is the same on the receiver
Click the Rx Display tab

Configure the receiver

Switch to the Rx Parameters tab
Ensure the IQ Sampling Rate and Frequency are the same as the transmitter
Switch to the Specify Modulation tab
Ensure the same modulation scheme is used for transmission
Switch to the Specify Packet tab
Ensure the packet structure is the same on the transmitter
Click the Specify Message tab
Press the run arrow

61
Note: If you decide to make any changes, click the STOP button and then change the
program options and run again. Changes do not take effect until you stop the program.

Click back to the Specify Modulation tab and change the modulation from QPSK to BPSK or
8-PSK and see how the Constellation Graph changes on the transmitter and the receiver
Note: Higher order modulation schemes may require optimizations such as digital
predistortion which is not covered in this course

Run the VI again with the new modulation scheme

BPSK Digital Signal QPSK Digital Signal

62
17. TIPS & TRICKS
17.1 10 functions you need to know about
These are the 10 most useful functions in LabVIEW, so you could already now learn how to
use them and where to find them!
Build Array

This example using the Build Array function inside a For loop in order build an array with 10
elements.

It is always useful to find a specific value in an array:

The Index Array is extendible, so you can drag it out to find more than one elements:

63
Find the size of an arbitrary array:

Depending on the input data, go to the Alarm case or the Write Data case.

This function concatenate several strings into on string:

64
Use this when you want to replace or remove a certain text in a string.

This is the most useful function when it comes to string manipulation.

65
This function converts a string into a number:

66
REFERENCES

67
68