LabVIEW Core 1 & 2 training

Course Overview

The first step in any NI LabVIEW learning path, LabVIEW Core 1 gives you the chance to explore the LabVIEW environment, dataflow programming, and common LabVIEW development techniques in a hands-on format. Learn to develop data acquisition, instrument control, data-logging, and measurement analysis applications. At the end of the course you will be able to create applications using the state machine design pattern to acquire, process, display, and store real-world data.

  • Instructor-led classroom: Three (3) days
  • New users and users preparing to develop applications using LabVIEW or NI Developer Suite
  • Users and technical managers evaluating LabVIEW or NI Developer Suite in purchasing decisions
  • Users pursuing the Certified LabVIEW Associate Developer certification
  • Complete Getting Started Modules
  • Experience with Microsoft Windows
  • Experience writing algorithms in the form of flowcharts or block diagrams
NI products used during the course
  • LabVIEW Professional Development System
  • NI Data Acquisition device
  • IEEE 488.2 (GPIB) controller
  • NI Instrument Simulator
  • BNC-2120

After attending this course, you will be able to:
  • Understand front panels, block diagrams, icons, and connector panes
  • Create user interfaces with charts, graphs and buttons
  • Use the programming structures and data types that exist in LabVIEW
  • Use various editing and debugging techniques
  • Create and save VIs for use as subVIs
  • Display and log data
  • Create applications that use data acquisition (DAQ) devices
  • Create applications that use GPIB and serial port instruments
  • Use the state machine design pattern in your applications

LabVIEW Core 1 course outline




Navigating LabVIEW

This lesson introduces the LabVIEW environment.

  • The LabVIEW environment including windows, menus, and tools
  • Creating and using LabVIEW projects
  • The LabVIEW front panel and block diagram
  • Searching for controls, VIs, and functions
Creating your first application

This lesson teaches you how to build a simple LabVIEW application that acquires analyses and presents data.

  • Understanding the dataflow programming model of LabVIEW
  • Recognising different data types
  • Tools for developing, cleaning and organising your VIs
  • Using Express VIs to build a basic VI

Troubleshooting and debugging VIs

This lesson teaches various debugging and error-checking techniques in LabVIEW. You will learn to identify problems with block diagram organisation or with data passing within a block diagram.

  • Correcting broken VIs
  • Using common debugging techniques
  • Addressing undefined or unexpected data
  • Implementing error checking and error handling

Using loops

This lesson presents the different ways that you can iteratively execute LabVIEW code and techniques for managing loop execution

  • Using structures like the While Loop and For Loop
  • Adding software timing to your code
  • Sharing data between loop iterations
  • Plotting data to a waveform chart

Creating and leveraging structures

This lesson introduces data types that combine related data into a single structure for improved data access and analysis.

  • Creating and using array controls and indicators
  • Creating and using cluster controls and indicators
  • Using type definitions to improve reuse of data structures in applications


Using decision-making structures

This lesson presents LabVIEW structures that you can use to implement decision-making algorithms in your applications

  • Creating and using Case structures
  • Creating and using Event structures

Modularity (SubVIs)

This lesson introduces modular programming in LabVIEW. In LabVIEW, VIs used within other VIs are called subVIs. You will learn how to build the icon and connector pane of a VI so that it can be used as a subVI

  • Basics of modular programming
  • Creating an icon and connector pane
  • Using a VI as a subVI
  • Creating subVIs from an existing VI


Acquiring measurements with hardware

This lesson describes the differences between NI DAQ systems and instrument control and how LabVIEW connects to hardware to get real-world measurements

  • Programming with the DAQmx API
  • Instrument control and programming with instrument drivers

Accessing files in LabVIEW

This lesson describes the basic concept of file I/O and teaches how to access and modify file resources in LabVIEW

  • High-level and low-level file I/O functions available in LabVIEW
  • Implementing File I/O functions to read and write data to files


Using sequential and state machine programming

This lesson introduces common LabVIEW design techniques and the state machine design pattern.

  • Techniques for sequential programming
  • Using state programming
  • Implementing a state machine design pattern


Course outline
The LabVIEW Core 2 course is an extension of the LabVIEW Core 1 course and teaches you to use common design patterns to successfully implement and distribute LabVIEW applications for research, engineering, and testing environments. Topics covered include programmatic control of your user interface, techniques to optimise reuse of existing code, use of file I/O functions, and tools to create executables and installers. This course directly links LabVIEW functionality to your application needs and provides a jump-start for application development.


  • Instructor-led classroom: Two (2) days


  • New users and users preparing to develop applications
  • LabVIEW Core 1 course attendees
  • Users and technical managers evaluating LabVIEW or NI Developer Suite in purchasing decisions
  • Users pursuing the Certified LabVIEW Associate Developer certification


  • Experience with Microsoft Windows
  • LabVIEW Core 1 or equivalent experience

NI products used during the course

  • LabVIEW Professional Development System
  • NI data acquisition device
  • BNC-2120

After attending this course, you will be able to:

  • Us local variables to modify front panel controls or stop parallel loops
  • Apply common design patterns that use queues and events
  • Programmatically control user interface objects
  • Evaluate file I/O formats and use them in applications
  • Modify existing code for improved usability
  • Prepare, build, debug, and deploy stand-alone applications

LabVIEW Core 2 course outline




Using variables

This lesson explains how to use local variables to modify front panel control values, stop parallel loops, and circumvent dataflow limitations.

  • Communicating between parallel loops
  • Using local and global variables
  • Writing to controls and reading from indicators
  • Understanding and avoiding race conditions

Communicating data between parallel loops

This lesson describes asynchronous communication techniques for creating code that is UI-driven and synchronises data between parallel loops.

  • Using queues to pass buffered data between loops
  • Using notifiers to broadcast data to multiple loops

Implementing design patterns

This lesson introduces you to design patterns. You learn about the specific benefits and functionality of these design patterns and how they can be used to reduce development time. You learn two different categories of programming design patterns: single loop and multiple loops.

  • Using single loop design patterns– Including the state machine design patterns and functional global variables
  • Using multiple loop design patterns–Including producer/consumer design patterns
  • Handling errors
  • Generating error codes and messages
  • Timing a design pattern

Controlling the user interface

This lesson describes methods to control the attributes of front panel objects programmatically, such as temporarily disabling a control. You learn how to use VI Server to access the properties and methods of front panel objects.

  • VI Server architecture
  • Using property nodes
  • Using invoke nodes
  • Creating and using control references

File I/O techniques

This lesson describes different file formats for collecting and storing data and how to select the appropriate file format for your applications. You practice implementing modular code that reads or writes measurement data.

  • Comparing file formats
  • Creating file and folder paths
  • Writing and reading binary files
  • Working with multichannel text files with headers
  • Accessing technical data management streaming (TDMS) files in LabVIEW and Excel

Improving an existing VI

This lesson focuses on methods to refactor inherited LabVIEW code and how to maximise reuse of existing code. Refactoring is the process of redesigning software to make it more readable and maintainable without altering its observable behaviour.

  • Refactoring inherited code
  • Typical issues when refactoring code

Creating and distributing applications

This lesson describes the process of creating stand-alone executables and installers for LabVIEW applications. You will learn how to use the Application Builder in LabVIEW.

  • Preparing the files
  • Creating build specifications
  • Creating and debugging an application
  • Creating an Installer