LabVIEW How-To

Configuring Objects

Adding Space to the Front Panel or Block Diagram without Resizing the Window
Changing Indicators to Controls
Changing Controls to Indicators
Clearing Front Panel Indicators
Coloring Objects and Backgrounds
Configuring Controls and Indicators
Configuring User-Defined Colors
Copying and Pasting Objects
Copying Colors from One Object to Another
Creating Transparent Objects
Displaying Hidden Front Panel Objects
Grouping and Locking Objects
Hiding Front Panel Controls and Indicators
Replacing a Front Panel Object from the Clipboard
Replacing Front Panel Objects
Scaling Front Panel Objects
Selecting Custom Colors
Setting Keyboard Shortcuts for Controls
Setting the Tabbing Order of Front Panel Objects
Showing and Hiding Labels and Digital Displays
Using and Configuring System Colors
Importing Graphics in LabVIEW

Importing Graphics in Mac OS
Importing Graphics in UNIX
Importing Graphics in Windows

Front Panel Controls and Indicators

Numeric Controls and Indicators

Boolean Controls

Creating a Radio Buttons Control
Creating and Operating Boolean Controls and Indicators
Changing the Mechanical Action of a Boolean Object
Customizing Boolean Objects with Imported Graphics
Labeling Buttons
Labeling Other Boolean Objects

String & Path Controls

Adding Strings in Combo Box Controls
Changing Values of Path Controls
Configuring Browse Options of Path Controls
Configuring Combo Box Controls to Allow Undefined String Values
Empty Paths
Entering a Carriage Return into a String
Entering a Linefeed into a String
Entering a Tab Character into a String
Entering or Changing Text in a String Control
Removing Strings from Combo Box Controls
Selecting and Entering Strings in Combo Box Controls at Run Time
Specifying Custom Values for Combo Box Strings
String Shortcut Menu Items

Backslash ('\') Codes Display
Hex Display
Limit to Single Line
Normal Display
Password Display
Scrollbar
Update Value while Typing

Array & Cluster Controls and Indicators

Variant Control and Indicator
Arrays

Changing Array Default Values
Changing Array Dimensions
Clearing an Array
Creating Array Controls and Indicators
Default Sizes and Values of Arrays
Determining the Size of Arrays
Displaying an Array in a Table
Displaying or Hiding Index Displays
Moving Arrays and Clusters
Resizing Arrays
Selecting, Cutting, Copying, and Pasting Array Cells
Setting Array Default Values
Tabbing through Elements of an Array or Cluster

Clusters

Changing Cluster Controls to Indicators and Cluster Indicators to Controls
Creating Cluster Controls and Indicators
Modifying Cluster Element Order
Moving Arrays and Clusters
Resizing Clusters
Setting Cluster Default Values
Tabbing through Elements of an Array or Cluster

Listboxes, Tree Controls, and Tables

Adding Symbols to Listboxes
Configuring Tree Controls
Creating a Tree Control
Creating Listboxes
Deleting Listbox Items
Disabling or Enabling Listbox Items
Displaying Components in Listboxes
Selecting Listbox Items at Run Time
Setting Case Sensitivity in Listboxes
Setting Column Widths at Run Time
Setting the Number of Items a User Can Select in Listboxes
Multicolumn Listboxes and Tables

Adding Header Text to a Multicolumn Listbox
Configuring Cells for Multiple Line Input
Creating Multicolumn Listboxes
Editing Data in Tables
Entering Data in Tables
Inserting or Deleting Rows or Columns in Multicolumn Listboxes
Inserting or Deleting Rows or Columns of Data in Tables
Resizing Rows and Columns in a Multicolumn Listbox or Table
Selecting Table Cells, Rows, or Columns
Showing and Hiding Multicolumn Listbox Column Headers
Using Tables

Graph Controls and Indicators

Adding a Plot to a Graph or Chart
Adding Cursors to Graphs
Configuring a Digital Waveform Plot
Configuring the X- and Y- Axes of a Graph or Chart
Creating a Chart
Creating a Graph
Cutting, Copying, and Pasting Digital Data
Deleting Cursors from Graphs
Formatting the X- and Y-Axes of a Graph or Chart
Graphing Digital Data
Inserting and Deleting Rows and Columns in the Digital Data Control
Zooming on a Graph or Chart

Ring & Enum Controls

Adding Text Items in Ring Controls
Adding Items to Enumerated Type Controls
Adding Picture Items to Ring Controls
Assigning Specific Values to Ring Control Items
Configuring Ring Controls to Allow Undefined Numeric Values
Creating a Ring Control
Creating an Enumerated Type Control
Disabling or Enabling Ring Control Items
Displaying Numeric Values of Ring Controls and Constants
Removing Items from Ring Controls
Selecting Items in Ring and Enumerated Type Controls at Run Time

Container Controls

Configuring Subpanel Controls
Loading a Front Panel in a Subpanel Control
Tab Controls

Adding Pages to Tab Controls
Configuring Options for Tab Controls
Configuring Tab Control Pages Programmatically
Creating Tab Controls
Duplicating Pages on Tab Controls
Removing Pages from Tab Controls
Reordering Pages on Tab Controls

I/O Controls and Indicators

Configuring DAQ Devices, Instruments, and Other Devices
Configuring I/O Controls

Refnum Controls

Refnum Controls and Indicators
Switching Between Strictly Typed and Weakly Typed Control Refnums
Types of Refnum Controls and Indicators

Dialog Controls and Indicators

Creating a Dialog Box

Labeling

Changing Captions Programmatically
Changing Text Characteristics
Creating Captions
Creating Free Labels
Editing Labels
Rotating Text Labels

Designing User Interfaces

Building the Block Diagram

Control and Indicator Data Types
Configuring Objects

Creating and Editing User-Defined Constants
Creating Controls and Indicators on the Block Diagram
Displaying SubVIs and Express VIs as Icons or Expandable Nodes
Displaying Terminals as Icons or Data Types
Inserting and Removing Inputs and Outputs
Inserting Block Diagram Objects
Placing Custom Controls and Indicators on Front Panels and Block Diagrams
Replacing Block Diagram Objects
Resizing Nodes

Wiring

Automatically Wiring Objects
Configuring Automatic Wiring
Deleting Wires
Displaying Terminals for VIs, Functions, and Express VIs
Moving Wires
Routing Wires
Selecting Wires
Wiring Techniques to Avoid
Wiring Structures

Assigning More Than One Value to a Sequence Local Terminal
Failing to Wire a Tunnel in All Cases of a Case Structure
Overlapping Tunnels
Wiring from Multiple Frames of a Stacked Sequence Structure

Using Polymorphic VIs

Building Polymorphic VIs
Editing the Shortcut Menus of a Polymorphic VI
Adding or Removing an Instance in a Polymorphic VI
Selecting the Instance of a Polymorphic VI Manually

Comparison

Comparing Arrays
Comparing Boolean Values
Comparing Characters
Comparing Clusters
Comparing Numeric Values
Comparing Strings
Determining Range Values and Coercing Data
Determining Range Values and Coercing Data in Arrays
Setting Comparison Functions to Compare Elements or Aggregates

Numeric Conversion

Changing Numeric Representation
Changing the Numeric Representation of a Control Refnum
Numeric Data Types

Complex Numbers
Floating-Point Numbers
Integers
Numeric Data Types Table
Unsigned Integers

Using Dynamic Data

Converting Data to the Dynamic Data Type
Converting Dynamic Data to Other Data Types

Using Express VIs

Configuring Express VIs
Creating a SubVI from an Express VI

Using Units

Associating Units with a Numeric Control or Indicator
Available Units in LabVIEW
Creating Polymorphic Units
Unit Syntax

Handling Variant Data

Adding Attributes to Variant Data
Converting Flattened Data to Variant Data
Converting LabVIEW Data to Variant Data
Converting Variant Data to LabVIEW Data
Deleting Attributes from Variant Data
Retrieving Attributes from Variant Data

Running and Debugging VIs

Correcting Broken VIs
Correcting Broken Wires
Disabling Debugging Tools
LabVIEW-Defined Command-Line Arguments
Launching a VI from the Command Line
Running VIs
Transfer Closing Main VI to Target VI
Debugging Techniques

Caveats and Recommendations when Using Custom Probes
Commenting out Sections of Block Diagrams
Creating Custom Probes
Determining the Current Instance of a SubVI
Displaying Warnings
Execution Highlighting
Single-Stepping
Suspending Execution
Using Indicators to View Probed Data
Using Supplied Probes
Using the Generic Probe
Using the Probe Tool
Placing and Removing Breakpoints

How LabVIEW Highlights Breakpoints
Node Breakpoint Example
Structure Breakpoint Example
Wire Breakpoint Example

Error Checking and Error Handling

Controlling Error Notification
Defining Custom Error Codes
Defining Custom Error Codes in Text Files
Distributing Custom Error Codes in Text Files
Error Cluster Reports
Finding Error Code Descriptions
Setting up Error I/O in a VI
Using Case Structures for Error Handling
Using Error Clusters
Using While Loops for Error Handling

Error Codes and Messages

Array and Cluster Errors

Block Diagram Error Messages

Cluster Is Invalid or Empty
Cluster Items Are Not Named Uniquely
Constant Has Undefined Type

FPGA Module Errors

Alias Not Configured
Alias Not Found
Alias Not Selected
Control/Indicator Not Available on Target VI
Emulation VI Broken
Emulation VI Interface Doesn't Match HDL Input Node Interface
Emulation VI Not Available
Enable Chain Handled Incorrectly
Error Calling Target Related Software
FIFO Unconfigured
Inputs/Outputs Unconfigured
Method Not Available for Current Target
No Method Selected
No Open Project Available to Define I/O Type
No Property Selected
Parameters of Method Changed
Property/Method Not Available for Selected I/O Resource
Target Not Selected
Target Software Not Found
Target VI Broken
Target VI Not Found
Target VI Not Selected
Target VI Running

Function Errors

Function Conflict
Function Is No Longer Supported
Function Not Found in Library
Function Not Supported by this Version
No Function Specified

Miscellaneous Errors

Bad Unit Syntax
Enumeration Conflict
Global VI Is Missing
Hidden Front Panel Control Has Undefined Type
Invalid Parameter Type
Invalid Return Type
Library Not Found or Failed to Load
No Item With This Name
No Library Specified
Refnum Conflict
Unassigned Output
Waveform Is Invalid

Node Errors

Bad Linkage to Method Information
Invalid Constructor
Invalid Method
Invalid Property
Invalid Refnum Class
Property Node Is Linked to a Strict Typedef
No Event Selected
Object Code Is Not Loaded

String Errors

Format Specifier Type Mismatch
Too Few Format Specifiers
Too Many Format Specifiers
Unknown Format Specifier

Structure Errors

Case Does Not Have Selector Value
Conditional Terminal Is Not Wired
Duplicate Items Selected in an Event Data Field Node
Duplicate Parameter Name
Dynamic Event Configuration Does Not Match Dynamic Event Registration
Event Specified by More Than One Event Case
Events Specified by Event Case Are Not Compatible with Each Other
Formula and Expression Node Error Messages
Invalid Parameter Name
Missing Assignment to Tunnel
Multiple Assignment to Tunnel
N Is Not Wired, and There Are No Indexing Inputs
No Case for Some Selector Values
One or More Event Cases Have No Events Defined
Reserved Parameter Name
Selector Values Are Not Unique
Selector Values Have Wrong Type
Sequence Local Has Sources on Separate Frames
Shift Register Data Type Is Undefined
Shift Register Is Unwired from Inside the Loop
Timeout Input Wired but Timeout Event Not Handled
Unassigned Sequence Local(s)
Unwired Input
Unwired Selector
User Event Data Type is Unnamed or Has Elements with No Names
You Have Initialized Some Shift Register Elements but Not All of Them

Subroutine Errors

LabVIEW Subroutine Link Error
Subroutine Priority VI Cannot Call a Non-Subroutine Priority SubVI
Subroutine Priority VI Cannot Contain an Asynchronous Node

SubVI Errors

Bad Linkage to SubVI
Polymorphic SubVI Is Broken
Recursive Reference
SubVI Is Already Running
SubVI Is In Interactive Retrieval Mode
SubVI Is In Panel Order or Cluster Order Mode
SubVI Is Missing
SubVI Is Not Executable

Wiring Errors

Array Element Conflict
Class Conflict
Contains Unwired or Bad Terminal
More Than One Index Input Is Wired
Required Input Is Not Wired
Scalar Array Conflict
This Variable Is Not Connected to Anything
This Wire Connects More Than One Data Sink but Has No Source
This Wire Connects More Than One Data Source
This Wire Is Not Connected to Anything
Undirected Tunnel
Wire Has Loose Ends
Wire Is a Member of a Cycle
You Have Connected a Control to a Control
You Have Connected an Indicator to an Indicator
You Have Connected Numeric Data Types That Have Incompatible Units
You Have Connected to a Polymorphic Terminal That Cannot Accept This Datatype
You Have Connected Two Arrays of Different Dimensions
You Have Connected Two Clusters with Different Contents
You Have Connected Two Terminals of Different Types

Ranges of LabVIEW Error Codes

Apple Event
Formula Parsing
General
GPIB
Instrument Driver
Mathematics
MATLAB and Xmath Script
Networking
Point By Point
Report Generation
Run-Time Menu
Serial
Signal Processing
SMTP
Storage
Timed Loop
VISA
Waveform
Windows Connectivity
Windows Registry Access

Undefined or Unexpected Data

Default Data in Arrays
Default Data in Loops
Preventing Undefined Data

Creating VIs and SubVIs

Creating an Icon
Creating Template VIs
Icon and Connector Pane Overview
Building Stand-Alone Applications or Shared Libraries (DLLs)

Building a Shared Library (DLL)
Building a Stand-Alone Application
Building an Application or Shared Library from an Existing Build Script
Caveats and Recommendations when Building Applications and Shared Libraries
Copying Your LabVIEW Work Environment Options
Creating an About Dialog Box for a Stand-Alone Application
Directories and Files Created when Building Applications and Shared Libraries
Enabling the Web Server in Applications
Properties and Methods Not Supported in the LabVIEW Run-Time Engine
Saving a Build Script
Using the LabVIEW Run-Time Engine

Setting up the Connector Pane

Assigning Terminals to Controls and Indicators
Confirming Terminal Connections
Deleting Terminal Connections
Selecting a Connector Pane Pattern
Setting Required, Recommended, and Optional Inputs and Outputs

Saving VIs

Converting Directories to LLBs
Converting LLBs to Directories
Creating Password-Protected VIs
Creating VI Libraries
Locking and Unlocking VIs
Marking VIs as Top-Level VIs in a Library
Removing Files from Libraries
Reverting to the Last Saved Version of a VI
Saving for a Previous Version
Saving Individual VI Files
Saving VIs in Existing Libraries

SubVIs

Avoiding SubVI Selections That Create Cycles
Avoiding SubVI Selections That Contain Front Panel Terminals inside Structures
Avoiding SubVI Selections That Contain More than 28 Objects
Creating SubVIs from Selections
Opening and Editing SubVIs
Placing SubVIs on Block Diagrams

VI Hierarchy

Searching in the VI Hierarchy
Viewing the Hierarchy of VIs

Loops and Structures

Configuring Structures

Placing Structures on the Block Diagram
Placing Objects inside Structures
Removing Structures without Deleting Objects in the Structure
Resizing Structures

For Loops and While Loops

Auto-Indexing
Changing the Continuation Behavior of a While Loop
Creating For Loops
Creating Shift Registers
Creating While Loops
Initializing a Feedback Node
Initializing Shift Registers and Using Previous Values
Preventing Code Execution in the First While Loop Iteration
Replacing a Feedback Node with Shift Registers
Replacing Shift Registers with a Feedback Node
Replacing Shift Registers with Tunnels
Replacing Tunnels with Shift Registers
Terminals Inside or Outside Loops
Using Shift Registers to Remember Iteration Values
Using While Loops for Error Handling

Case, Sequence, Event, and Conditional Disable Structures

Adding Cases to the Middle of an Ordered List
Adding and Duplicating Subdiagrams
Adding and Removing Sequence Local Terminals
Creating Case Structures
Creating Conditional Disable Structures
Deleting Subdiagrams
Moving between Subdiagrams
Rearranging Subdiagrams
Shift Subdiagram To Case Example
Specifying a Default Case
Swapping and Shifting Case Subdiagrams
Swap Subdiagram With Case Example

Event-Driven Programming

Adding and Duplicating Event Cases
Available Events
Avoid Placing Two Event Structures in One Loop
Avoid Using an Event Structure Outside a Loop
Caveats and Recommendations when Using Events in LabVIEW
Configuring Events Handled by the Event Structure
Dynamically Registering Events
Handling a Latched Stop Boolean Control in an Event Structure
Locking Front Panels
Make Sure You Have a Register For Events Node for Each Event Structure
One Case Handling Multiple Filter Events
One Case Handling Multiple Notify Events
Prompting Users with Dialog Boxes in a Mouse Down? Event Case
Use Events for Direct User Interaction Only
Using Events versus Using the Wait for Front Panel Activity Function
Using Events with Latched Boolean Controls
Events

Control Class

Key Down
Key Down?
Key Repeat
Key Repeat?
Key Up
Mouse Down
Mouse Down?
Mouse Enter
Mouse Leave
Mouse Move
Mouse Up
Value Change
ListBox

Double Click
Drag
Drag?
Drop
Drop?
Item Close
Item Close?
Item Open
Item Open?

VI Class

Key Down
Key Down?
Key Repeat
Key Repeat?
Key Up
Menu Activation?
Menu Selection (App)
Menu Selection (User)
Menu Selection? (App)
Mouse Down
Mouse Down?
Mouse Enter
Mouse Leave
Mouse Move
Mouse Up
Panel Close
Panel Close?
Panel Resize

Application Class

Application Exiting
Application Exit?
Timeout

Strings

Grouping Data Using Strings, Arrays, and Clusters

Converting LabVIEW Data to XML
Converting Numbers into Strings
Converting XML to LabVIEW Data
Formatting Strings
Format Specifier Examples
Format Specifier Syntax
Format Specifiers Syntax Elements
Inserting Non-Displayable Characters in Strings
LabVIEW XML Schema
Replacing Text in a String at a Specified Point
Replacing Text in Strings
Searching for and Replacing Text in a String
Special Characters for Match Pattern
Splitting Strings
Using Format Strings

Arrays

Converting an Array to a Cluster
Creating Array Constants
Deleting Elements, Rows, Columns, and Pages within Arrays
Inserting Elements, Rows, Columns, and Pages into Arrays
Replacing Elements, Rows, Columns, and Pages within Arrays

Clusters

Bundling Elements into Clusters
Converting a Cluster to an Array
Creating Cluster Constants
Replacing Cluster Elements
Unbundling Elements from Clusters
Unbundling Elements from Clusters by Name

Local and Global Variables

Initializing Local and Global Variables
Avoiding Race Conditions
Read and Write Variables
Local Variables

Changing the Data Direction of a Local Variable
Creating Local Variables
Memory Considerations when Using Local Variables
Reading from One Front Panel Object and Writing to Two Block Diagram Locations
Writing to One Front Panel Object from Two Block Diagram Locations

Global Variables

Changing the Data Direction of a Global Variable
Creating Global Variables
Creating Template Global Variables
Memory Considerations when Using Global Variables

Graphs and Charts

Adding a Plot to a Graph or Chart
Adding Markers to X- and Y-Scales on a Graph or Chart
Adding Multiple X- and Y- Scales on Graphs or Charts
Changing Format and Precision of Graph and Chart Axes
Changing the Numeric Representation of a Waveform
Clearing the Data on Graphs and Charts
Configuring the X- and Y- Axes on a Graph or Chart
Formatting the X- and Y- Axes on a Graph or Chart
Scrolling through a Graph or Chart
Zooming on a Graph or Chart
Graphs

Adding Cursors to Graphs
Configuring a Digital Waveform Plot
Creating a Graph
Graphing Digital Data
Graphing Waveform Data
Graphing XY Data
Ignoring Time Stamp and Plot Labels in Graphs
Plotting X, Y, and Z Data on a 3D Surface Graph

Charts

Charting Waveform Data
Creating a Chart

Graphics and Sound

Displaying Pixels Not Visible in a Picture Indicator
Using Sound Input and Sound Output Devices

File I/O

Basics of File I/O

Formatting and Writing Data to a File
Scanning a File for Data
Selecting a File
Selecting a File for Reading and Writing
Selecting a File Programmatically for Reading and Writing
Selecting a File through a Dialog Box

Choosing a File I/O Format

File I/O with Binary Files
File I/O with Datalog Files
File I/O with LabVIEW Measurement Data Files
File I/O with NI Test Data Exchange Format Files
File I/O with Text and Spreadsheet Files
Reading 1D or 2D Data from Binary Files
Reading from Binary Files
Reading from Datalog Files
Reading from Spreadsheet Files
Reading from Text Files
Reading Waveform Data from a File Using Storage VIs
Writing 1D or 2D Data to Binary Files
Writing to Binary Files
Writing to Datalog Files
Writing to Spreadsheet Files
Writing to Text Files
Writing Waveform Data to a File Using Storage VIs

Creating Configuration Files

Using Configuration File VIs

Logging Front Panel Data

Changing the Log-File Binding
Clearing the Log-File Binding
Datalog Type
Deleting a Datalog Record
Enabling Datalogging
Retrieving Data Programmatically
Retrieving Data Using File I/O
Retrieving Logged Front Panel Data Using a SubVI
Selecting the Default Data Directory
Viewing Logged Data Interactively

Documenting and Printing VIs

Documenting VIs

Printing Documentation

Generating HTML Documentation for VIs, Templates, and Objects
Generating RTF Documentation for VIs, Templates, and Objects
Generating Text Documentation for VIs, Templates, and Objects
Naming Conventions for Image Files that LabVIEW Generates
Printing Documentation for VIs, Templates, and Objects

Setting up the VI Revision History

Adding Comments to the Revision History
Resetting the VI Revision History and Revision Number
Viewing the VI Revision History

Creating and Editing VI Descriptions
Creating Compiled Help Files
Creating Object Descriptions and Tip Strips
Linking VIs to HTML Files or Compiled Help Files

Printing VIs

Enhancing Printouts
Generating Images of Individual Front Panel Objects
Printing VIs Programmatically
Troubleshooting Printer Errors

Generating Reports

Formatting Data for Report Generation
Using Tokens in Reports

Customizing VIs

Changing a VI's Window Title
Copying Browse Paths and Keywords
Opening SubVI Front Panels During Execution
Preparing Example VIs to Appear in the NI Example Finder
Setting Execution Properties
Setting Window Appearance and Size
Customizing Menus

Application Item Tags
Customizing Menus Programmatically
Customizing Menus Statically
Handling Menu Selections
Showing and Hiding Menu Bars
Viewing Application Items

Programmatically Controlling VIs

Adding New Exported VIs Entries
Adding New TCP/IP Access List Entries
Configuring the VI Server
Controlling Front Panel Objects Programmatically from a SubVI
Creating a Strictly Typed VI Reference
Creating Control Reference SubVIs from Property Nodes and Invoke Nodes
Creating Property Nodes and Invoke Nodes
Editing Existing Exported VIs Entries
Editing Existing TCP/IP Access List Entries
Linking Property Nodes and Invoke Nodes to Terminals
Removing TCP/IP Access List Entries
Removing VIs from the Exported VIs List
Setting TCP/IP Access for the VI Server
Specifying Which VIs You Can Control Remotely
VI Server

LabVIEW How-To

Resources