LabVIEW (Laboratory Virtual Instrumentation Engineering Workbench) Training

program
Scope
The training program introduces industrial automation and guides the participants in exploring the
LabVIEW environment. This training imparts the skills to develop code and extend graphical design
capabilities for measurement and automation. The learning provides platform to excel in various tools,
design techniques, and ways of plotting data results in building virtual instrumentation or a prototype
of a plant. LabVIEW is unmatched in helping to reduce test times, deliver business insights based on
collected data, and translate ideas into reality.

LabVIEW is the easiest, most powerful tool for acquiring, analyzing, and presenting real-
world data.
 Course Title and Who Should Attend
Description
LabVIEW Core 1 New LabVIEW users and users
preparing to develop
applications using LabVIEW or
NI Developer Suite
LabVIEW Core 2 New LabVIEW users and users
preparing to develop
applications using LabVIEW or
NI Developer Suite
LabVIEW NXG Core New users and users preparing
2: Create User-Driven to develop applications using
Applications LabVIEW NXG
LabVIEW Core 3 Engineers who need to learn
best practices for application
and project design in LabVIEW
LabVIEW NXG Core New users and users preparing
1: Acquire, Analyze, to develop applications using
Visualize LabVIEW NXG
Transitioning to Experienced LabVIEW users
LabVIEW NXG who want to begin using
LabVIEW NXG for code
development.
Object-Oriented Experienced LabVIEW users
Design and interested in using object-
Programming in oriented programming
LabVIEW architectures
Managing Software Anyone managing the
Engineering in development of a medium to
LabVIEW large project in LabVIEW
Advanced Experienced LabVIEW users
Architectures in architecting medium to large
LabVIEW applications
Embedded Control Recommended - Users
and Monitoring Using preparing to develop embedded
LabVIEW control and monitoring
applications using LabVIEW
Real-Time and LabVIEW
FPGA with CompactRIO,
Single-Board RIO, PXI, or R
Series multifunction RIO
devices. Users who need the
performance and reliability of
Real-Time and FPGA
hardware targets
Actor-Oriented Experienced LabVIEW users
Design in LabVIEW who are designing medium to
large applications that require
a high level of concurrency.
Wireless Prototyping Communications algorithm
Fundamentals using designers who need to
NI SDR and prototype next generation
LabVIEW wireless communications
Communications systems or Engineers using
System Design Suite software defined radio for rapid
prototyping of wireless
communication systems
Prerequisites Duration
Experience with Microsoft 5 Days
Windows and writing
algorithms (flowcharts, block
diagrams)
LabVIEW Core 1 or experience 5 Days
navigating and programming
small applications in LabVIEW
LabVIEW NXG Core 1 or 4 Days
equivalent experience
LabVIEW Core 1 and 2 or 5 days
experience programming small
to medium LabVIEW
applications
Experience with Microsoft 4 Days
Windows and writing
algorithms (flowcharts, block
diagrams)
LabVIEW Core 1 and 2 or 2 days
equivalent experience.
LabVIEW Core 3 or experience 3 Days
programming medium to large
LabVIEW applications
LabVIEW Core 3 or experience 2 Days
programming medium to large
LabVIEW applications
LabVIEW Core 3 or experience 3 Days
programming medium to large
LabVIEW applications
LabVIEW Core 1 & 2 courses 6 Days
or equivalent experience
LabVIEW Core 3 Object- 3 Days
Oriented Design and
Programming in LabVIEW
Knowledge of basic digital 4 Days
communications concepts
 LabVIEW Engineers who need to improve
Performance performance and optimize their
LabVIEW code
LabVIEW Engineers wishing to extend
Connectivity the functionality of LabVIEW
applications through network
technologies
Using LabVIEW and Design verification engineers,
TestStand in manufacturing test engineers,
Regulated Industries and people on Software Quality
or Design Assurance teams
who review code written in
LabVIEW or TestStand.
LabVIEW Core 1 and 2 or 2 Days
experience programming small
to medium LabVIEW
applications
LabVIEW Core 2 or experience 3 Days
programming small to medium
applications in LabVIEW
Basic understanding of 2 Days
LabVIEW and the
environment. LabVIEW
programming experience is not
essential for this course, but
helpful. Some familiarity with
FDA regulations and rigors of
working in the medical device
industry or other highly
regulated industry.

LabVIEW Core 1
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. In this course you
will 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.
Course Objectives:
 Learn how to develop basic applications in the LabVIEW graphical
programming environment
 Create applications using a state machine design pattern
 Read and write data to file
Who Should Attend
New LabVIEW users and users preparing to develop applications using LabVIEW or
NI Developer Suite
Prerequisites
Experience with Microsoft Windows and writing algorithms (flowcharts, block
diagrams)
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

Course Outline
Lesson Overview
This lesson introduces the
Navigating LabVIEW
LabVIEW environment.
This lesson teaches you how to
build a simple LabVIEW
Creating Your First Application
application that acquires analyzes
and presents data.
This lesson teaches various
debugging and error-checking
techniques in LabVIEW. You will
Troubleshooting and Debugging
learn to identify problems with
Vis
block diagram organization or
with data passing within a block
diagram.
This lesson presents the different
Using Loops ways that you can iteratively
execute LabVIEW code and
Topics
 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
 Understanding the dataflow
programming model of
LabVIEW
 Recognizing different data
types
 Tools for developing, cleaning
and organizing your VIs
 Using Express VIs to build a
basic VI
 Correcting broken VIs
 Using common debugging
techniques
 Addressing undefined or
unexpected data
 Implementing error checking
and error handling
 Using structures like the
While Loop and For Loop

Creating and Leveraging
Structures
Using Decision-Making Structures
Modularity (SubVIs)
Acquiring Measurements with
Hardware
Accessing Files in LabVIEW
Using Sequential and State
Machine Programming
techniques for managing loop
execution
This lesson introduces data types
that combine related data into a
single structure for improved data
access and analysis.
This lesson presents LabVIEW
structures that you can use to
implement decision-making
algorithms in your applications
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
This lesson describes the
differences between NI DAQ
systems and instrument control
and how LabVIEW connects to
hardware to get real-world
measurements
This lesson describes the basic
concept of file I/O and teaches how
to access and modify file resources
in LabVIEW
This lesson introduces common
LabVIEW design techniques and
the state machine design pattern.
 Adding software timing to
your code
 Sharing data between loop
iterations
 Plotting data to a waveform
chart
 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
 Creating and using Case
structures
 Creating and using Event
structures
 Basics of modular
programming
 Creating an icon and
connector pane
 Using a VI as a subVI
 Creating subVIs from an
existing VI
 Programming with the
DAQmx API
 Instrument control and
programming with
instrument drivers
 High-level and low-level file
I/O functions available in
LabVIEW
 Implementing File I/O
functions to read and write
data to files
 Techniques for sequential
programming
 Using state programming
 Implementing a state
machine design pattern
 LabVIEW Core 2
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 optimize
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.
Course Objectives:
 Design, implement, and distribute stand-alone applications using LabVIEW
 Apply single- and multiple-loop design patterns for application functionality
Who Should Attend
New LabVIEW users and users preparing to develop applications using LabVIEW or
NI Developer Suite
Prerequisites
LabVIEW Core 1 or experience navigating and programming small applications in
LabVIEW
After attending this course, you will be able to:
 Use 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

Course Outline
Lesson Overview Topics
Using Variables This lesson explains how to use Communicating between parallel
local variables to modify front loops
panel control values, stop parallel Using local and global variables
loops, and circumvent dataflow Writing to controls and reading
limitations. from indicators
Understanding and avoiding race
conditions
Communicating Data Between This lesson describes Using queues to pass buffered data
Parallel Loops asynchronous communication between loops
techniques for creating code that is Using notifiers to broadcast data to
UI-driven and synchronizes data multiple loops
between parallel loops.
Implementing Design Patterns This lesson introduces you to Using single loop design
design patterns. You learn about patterns– Including the state
the specific benefits and machine design patterns and
functionality of these design functional global variables
patterns and how they can be used Using multiple loop design
to reduce development time. You patterns–Including
learn two different categories of producer/consumer design
programming design patterns: patterns
single loop and multiple loops. Handling errors
Generating error codes and
messages
Timing a design pattern
Controlling the User Interface This lesson describes methods to VI Server architecture
control the attributes of front panel Using property nodes
objects programmatically, such as Using invoke nodes
temporarily disabling a control. Creating and using control
You learn how to use VI Server to references
access the properties and methods
of front panel objects.
File I/O Techniques This lesson describes different file Comparing file formats
formats for collecting and storing Creating file and folder paths
data and how to select the Writing and reading binary files
appropriate file format for your
 applications. You practice
implementing modular code that
reads or writes measurement data.
Improving an Existing VI This lesson focuses on methods to
refactor inherited LabVIEW code
and how to maximize reuse of
existing code. Refactoring is the
process of redesigning software to
make it more readable and
maintainable without altering its
observable behavior.
Creating and Distributing This lesson describes the process of
Applications creating stand-alone executables
and installers for LabVIEW
applications. You will learn how to
use the Application Builder in
LabVIEW.
Working with multichannel text
files with headers
Accessing Technical data
management streaming (TDMS)
files in LabVIEW and Excel
Refactoring inherited code
Typical issues when refactoring
code
Preparing the files
Creating build specifications
Creating and debugging an
application
Creating an Installer

LabVIEW Core 3
LabVIEW Core 3 introduces you to structured practices to design, implement,
document, and test LabVIEW applications. This course focuses on developing
hierarchical applications that are scalable, readable, and maintainable. The
processes and techniques covered in this course help reduce development time and
improve application stability. By incorporating these design practices early in your
development, you avoid unnecessary application redesign, increase VI reuse, and
minimize maintenance costs.
Course Objectives:
 Follow an agile software development process to desgin, implement, document,
and test key application features
 Learn the skills needed to create scalable, readable, and maintainable
applications
 Recommended preparation for the Certified LabVIEW Developer exam
Who Should Attend
Engineers who need to learn best practices for application and project design in
LabVIEW
Prerequisites
LabVIEW Core 1 and 2 or experience programming small to medium LabVIEW
applications
After attending this course, you will be able to:
 Develop an application in an agile manner.
 Use Project Explorer Window tools to improve file organization and resolve file
conflicts.
 Use the Queued Message Handler project template to develop a multi-loop
application.
 Use notifiers for one-to-many communication between parallel loops.
 Develop a customized user interface prototype for initial usability testing.
 Handle errors locally or globally depending on the severity of the error.
 Develop, integrate, and test scalable, readable, and maintainable code modules.

Course Outline
Lesson Overview Topics
Developing Successful This lesson describes various Scalable, Readable, Maintainable
Applications development techniques that enable you VIs
to create scalable, readable, and Software Development Practices
maintainable VIs. You learn the Overview
importance of following a software Requirements
development process and how to develop Task Analysis
code that satisfies project requirements.
Organizing the Project This lesson describes tools and techniques Project Libraries
for organizing and managing files in a Project Explorer Tools and
LabVIEW project. You learn how to create Organization
and use project libraries, how to use Project Conflicts
various tools to learn more about each
LabVIEW project file, and how to identify,
resolve, and prevent cross-linking errors
and file conflicts.
Creating an Application This lesson introduces techniques and Architecture Testing
Architecture programming practices for creating LabVIEW Style Guidelines
intuitive and robust architectures for User Events
large applications. You learn the Queued Message Handler
importance of testing your top-level Application Data Types
architecture, the value of following Notifiers
established style guidelines, how to
implement user events and notifiers, and
how to use the queued message handler
project template to begin development of
a multi-loop application.
Customizing the User This lesson introduces techniques to User Interface Style Guidelines
Interface improve the way you implement front User Interface Prototypes
panels in LabVIEW. You learn how to use Customizing a User Interface
runtime menus, splitter bars, panes, Extending a User Interface
subpanels, and tab controls to customize Window Appearance
and extend your user interface. You also User Documentation

Managing and Logging Errors
Creating Modular Code
learn the value of creating a user interface Application Initialization
prototype and techniques for improving User Interface Testing
the usability of your application.
This lesson describes several approaches Error Testing
to developing software that gracefully Local Error Handling
responding to different types of errors. Global Error Handling
You learn how to determine whether an Error Logging
error should be handled locally or globally
and when you should log error data to disk
for later analysis.
This lesson describes how to use modular Designing Modular Applications
code in a large application and guidelines Code Module Testing
for making large applications more Integration Testing
maintainable. You learn several
approaches for testing code modules and
integrating them into your top-level
application architecture.

LabVIEW NXG Core 1:Acquire, Analyze, Visualize

The first step in the LabVIEW NXG learning path, LabVIEW NXG Core 1 gives you
the chance to explore the LabVIEW NXG environment, interactive analysis, dataflow
programming, and common development techniques in a hands-on format. In this
course, you will 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, analyze,
process, visualize, and store real-world data.
Course Objectives:
 Interactively acquire and analyze data from NI hardware (NI DAQ devices) and
non-NI instruments (GPIB instruments)
 Create and program a LabVIEW NXG application that acquires, analyzes, and
visualizes data
 Create user interfaces with charts, graphs, and buttons
 Use programming structures, data types, and the analysis and signal processing
algorithms in LabVIEW NXG
 Debug and troubleshoot applications
 Work with sets of single-channel and multi-channel data
 Log data to file
 Use best programming practices for code reuse and readability
 Implement a sequencer using a state machine design pattern
Who Should Attend
New users and users preparing to develop applications using LabVIEW NXG
Prerequisites
Experience with Microsoft Windows and writing algorithms (flowcharts, block
diagrams)
After attending this course, you will be able to:
 Interactively acquire and analyze data from NI hardware (NI DAQ devices) and
non-NI instruments (GPIB instruments)
 Create and program a LabVIEW NXG application that acquires, analyzes, and
visualizes data
 Create user interfaces with charts, graphs, and buttons
 Use programming structures, data types, and the analysis and signal processing
algorithms in LabVIEW NXG
 Debug and troubleshoot applications
 Implement a sequencer using a state machine design pattern
LabVIEW NXG Core 1 Course Outline
Lesson Overview Topics
Introduction to LabVIEW NXG You will learn about LabVIEW  What is LabVIEW NXG?
NXG.
 Common types of LabVIEW
NXG applications
First Measurement (NI DAQ You will learn how to interactively  Connect your NI DAQ device
Device) acquire, analyze, and visualize
 Validate the data
data from an NI data acquisition
(DAQ) device.  Troubleshoot unexpected I/O
results
First Measurement (Non-NI You will learn how to interactively  Connect your non-NI
Instrument) acquire, analyze, and visualize instrument
data from a non-NI instrument.
 Validate the data using an
instrument driver example
program
 Troubleshoot unexpected I/O
results
Exploring an Existing Application You will learn how to explore an  Explore a project and VI
existing LabVIEW NXG project
 Determine VI behavior based
and application and predict the
on dataflow programming
behavior of the application.
model
Creating Your First Application You will learn how to create a  Create a new project and VI
simple LabVIEW NXG application
 Use different data types
that acquires, analyzes, and
visualizes data.  Use hardware APIs to
communicate with hardware
 Develop an acquire-analyze-
visualize VI that acquires

Debugging and Troubleshooting
Executing Code Repeatedly Using
Loops
Working with Sets of Data
Executing Code Based on
Condition (Case Structure)
Writing and Reading Data to File
Reusing Code (SubVIs)
Grouping Data of Mixed Data Types
(Clusters)
Propagate Data Type Changes
Using G Types
Implementing a Sequencer (State
Machine)
data from NI DAQ devices and
non-NI instruments
You will learn how to debug and  Correct a broken VI
troubleshoot a LabVIEW NXG
 Use debugging techniques
application.
and tools
 Capture data from VI panel
 Manage and display errors
You will learn how to execute code  Use While Loop and For Loop
repeatedly using While Loops and
 Add timing to loops
For Loops.
 Access data from previous
loop iterations
You will learn about data types  Use the array and waveform
that represent sets of data and data types
how to use and process them.
 Work with multi-channel
acquisition data
 Explore additional array and
waveform examples
a You will learn how to execute code  Create and configure Case
based on a condition. structures
 Common examples
You will learn about the basic  Write data to text file
concept of file I/O and how to
 Programmatically create file
access and modify file resources in
and folder paths
LabVIEW NXG.
 Analyze data in a text file
 Compare file formats
You will learn about modular  Understand modularity
programming and how to use
 Create subVI icon and
subVIs to reuse code and improve
connector pane
code readability.
 Document a subVI
You will learn how to group data of  Create a cluster
mixed data types into a cluster to
 Disassemble and modify
improve data organization and
clusters
code readability.
 Error clusters
 Visualize clusters and cluster
arrays
You will learn how to  Why use G types?
automatically propagate data
 Creating and using a G type
types changes to a G type to all
instances of that G type.
You will learn about common  Techniques for sequential
sequential LabVIEW NXG design programming
techniques and the state machine
 Using state programming
design pattern.
 Implementing a state
machine design pattern
 Transitioning to LabVIEW NXG
For experienced LabVIEW users who want to begin using LabVIEW NXG for code
development, this course guides you through the transition experience from
LabVIEW 2017 and earlier to LabVIEW NXG, easing the migration of your
development skills and existing applications to the new environment.
Learn the fundamental differences between the LabVIEW 2017 and LabVIEW NXG
development environments, techniques for new application development using
LabVIEW NXG, and how to use the Code Conversion Utility to migrate a qualified
application for use in LabVIEW NXG.
Course Objectives:
 Describe the fundamental differences between the LabVIEW 2017 and LabVIEW
NXG development environments.
 Develop and deploy a state machine application from scratch using LabVIEW
NXG.
 Use the Code Conversion Utility and LabVIEW NXG development techniques to
migrate a qualified application for use in LabVIEW NXG.
Who Should Attend
Experienced LabVIEW users who want to begin using LabVIEW NXG for code
development.
Prerequisites
LabVIEW Core 1 and 2 or equivalent experience.

After attending this course, you will be able to:

 Describe the fundamental differences between the LabVIEW and LabVIEW NXG
development environments.
 Develop and deploy a state machine application from scratch using LabVIEW
NXG.
 Use the Code Conversion Utility and LabVIEW NXG development techniques to
migrate a qualified application for use in LabVIEW NXG.

Transitioning to LabVIEW NXG Course Outline

Lesson Overview Topics
Exploring the You will learn about changes to software  Installing and updating NI software
LabVIEW NXG installation and explore the LabVIEW NXG
 Launching LabVIEW NXG
Environment environment.
 Launching a project
 Learning to program
 Searching for LabVIEW NXG content
Configuring Hardware You will learn how to connect to your  Exploring detected hardware
hardware and verify its functionality in
 Adding undetected hardware
LabVIEW NXG.
 Ensuring that hardware is working
Developing VIs You will learn how to develop a VI in  Creating Vis
LabVIEW NXG. This lesson also describes
 Creating a subVI
how to prepare a VI for use as a subVI in
LabVIEW NXG and changes to VI  Documenting your code
documentation.
Appendix: Developing You will create a simple object-oriented  Creating a Class
Object-Oriented application that uses inheritance and
 Defining an Inheritance Relationship
Applications dynamic dispatch.
 Overriding Inherited Methods
Debugging and You will learn to use various  Resolving compiler errors
Troubleshooting LabVIEW NXG tools to determine the root
 Handling run-time errors
cause of compiler errors and debug incorrect
execution.  Debugging incorrect execution
Distributing Code You will package LabVIEW NXG code for  Preparing code for distribution
distribution and create a distribution for
 Building an executable
use by other developers and end-users.
  Distributing an executable
Putting it All Together: You will use your LabVIEW NXG  Create a state machine application that
Create a State knowledge to create an application that conditionally flashes an LED
Machine uses a state machine to implement the
functionality described by a flowchart.
Migrating Simple VIs You will learn the high-level process for  What is the process for code migration?
migrating your existing code for use in
 Preparing code for migration
LabVIEW NXG. You will then use the Code
Conversion Utility to convert simple VIs  Converting a simple VI
and your LabVIEW NXG expertise to finish  Finishing migration of a simple VI
migration of those VIs.
 Migrating a simple VI that uses
hardware
Appendix: Migrating You will learn how you can call the Code  Converting code through the command
Reuse Libraries Conversion Utility through command line line
instructions.
 Finishing migration of reusable code
You will also learn how the code migration
process may change when migrating
reusable code.
Calling Existing VIs You will learn when you would want to call  Why call an existing VI from
from LabVIEW NXG existing VIs directly from LabVIEW NXG LabVIEW NXG?
without migrating them. You will also learn
 Calling existing VIs from
how to call an existing VI within
LabVIEW NXG
LabVIEW NXG.
Migrating and You will learn how the migration process  Converting an application
Application may differ for larger, more complex VIs and
 Finishing migration of an application
LabVIEW applications.
Object-Oriented Design and Programming in LabVIEW
Object-oriented (OO) programming has demonstrated its superiority over procedural
programming for solving a variety of problems. Object-oriented design encourages
cleaner interfaces between sections of code and results in code that is easier to debug
and scales better for large programming teams. Object-oriented programming is the
development of code in a language that enforces object-oriented design principles.
This course covers the fundamental concepts of object-oriented design and
programming and then demonstrates how those concepts are implemented in
LabVIEW.
Course Objectives:
 Evaluate object-oriented design priciples for the development of an application
 Implement a basic class hierarchy using LabVIEW classes
 Use LabVIEW features that provide additional functionality to LabVIEW classes
 Implement an application using common object-oriented design patterns
 Modify an existing LabVIEW application to replace common patterns with
LabVIEW objects
Who Should Attend
Experienced LabVIEW users interested in using object-oriented programming
architectures
Prerequisites
LabVIEW Core 3 or experience programming medium to large LabVIEW applications
After attending this course, you will be able to:
 Determine the appropriateness of using an
object-oriented approach to develop an application
 Design an application using object-oriented design principles
 Implement a basic class hierarchy using LabVIEW classes
 Use LabVIEW features that provide additional functionality to LabVIEW classes
 Implement an application using common
object-oriented design patterns
 Modify an existing LabVIEW application to replace common patterns with
LabVIEW objects

Course Outline
Lesson Overview Topics
Introduction Given a development project, the learner  What is a Class?
will be able to determine if an object-
 What is an Object?
oriented approach should be used for
designing and implementing the  What is Object-Oriented Design?
application.  What is Object-Oriented Programming?
Designing an Object- Given a development project, the learner  Object-Oriented Design
Oriented Application will be able to derive a class hierarchy for
 Differentiating Classes
the application using object-oriented
design principles.  Identifying Classes and Methods
 Class Relationships
 Common Design Mistakes
Object-Oriented Given a development project and a class  Introduction to Object-Oriented
Programming in hierarchy, the learner will be able to Programming in G
LabVIEW develop and use classes in LabVIEW that
 LabVIEW Classes
are readable, scalable, maintainable, and
reusable.  Encapsulation
 Inheritance
 Dynamic Dispatch
 Tools
 Common Use Cases
Object-Oriented Given a development project and a class  Object References and Construction
Tools and Design hierarchy, the learner will be able to Guarantees
Patterns develop an object-oriented LabVIEW
 Front Panel Displays for Object Data
application that leverages one or more
existing tools or design patterns.  Design Patterns: Introduction

Reviewing an Object- Given a completed LabVIEW application,
Oriented Application the learner will be able to review,
refactor, and deploy the code using good
object-oriented design and programming
practices.
 Channeling Pattern
 Aggregation Pattern
 Factory Pattern
 Design Patterns: Conclusion
 Code Review
 Migrating to LabVIEW Classes
 Deployment
 Additional Resources

Managing Software Engineering in LabVIEW

Learn to cultivate the skills you need to effectively manage and deliver large NI
LabVIEW applications in single- or multi-developer environments. Also obtain
common practices for managing large, team-oriented projects from specification to
deployment. By incorporating these application development practices, you can
improve development processes and optimize applications and resources to effectively
reduce development time and costs.
View the course outline | View a sample of the course materials

Course Objectives:
 Learn to manage the development of a LabVIEW project from definition to
deployment
 Select and use appropriate tools and techniques to manage the development of a
LabVIEW application
 Recommended preparation for Certified LabVIEW Architect exam
Who Should Attend
Anyone managing the development of a medium to large project in LabVIEW
Prerequisites
LabVIEW Core 3 or experience programming medium to large LabVIEW applications
After attending this course, you will be able to:
 Manage LabVIEW projects that require timely delivery of a quality solution that
satisfy application requirements and regulatory standards
 Manage development of a LabVIEW project from definition to deployment
 Adapt the software engineering process, as presented in this course, to your
LabVIEW development projects
 Select and leverage appropriate tools and techniques for managing the
development of your LabVIEW application
 Conduct an effective LabVIEW code review
 Develop a strategy for testing and validating your application
 Select an appropriate method for deploying your applications to other developers
and end users

Course Outline
Lesson Overview Topics
Introduction This lesson introduces the  Software engineering process
software development process and
 Roles of a LabVIEW architect
defines the role of a LabVIEW
Architect. You also learn about  Configuration management
tools to monitor and control the
evolution of a software product
Requirements Gathering This lesson describes how to plan a  Project management
LabVIEW project. In this lesson
 Gathering and managing
you learn how to identify
requirements
appropriate tools for managing a
project and tracking its progress.  Time estimation
You also learn how to estimate the
 Style and coding standards
time required to complete a
project. This lesson culminates in  Developing a project plan
the creation of a project plan for
development of a LabVIEW
project.
Design This lesson describes tools and  Creating a software model
practices you can use to aid in
 Designing a software
designing a LabVIEW project. You
architecture
learn how to develop a graphical
model of the application, how to  Creating a prototype
develop a prototype for the user
 Developing a design
interface, and how to develop a
document
design document that will be used
throughout project development.
Development In this lesson, you use tools in  Automating development
LabVIEW to improve the tasks
development of LabVIEW projects.
 Code reviews
You learn about existing tools for
 automating development tasks as
well as how to develop your
own. You also learn how to
prepare for and conduct an
effective code review.
Validation In this lesson, you learn the  Static code analysis
importance of testing code for
 Dynamic code analysis
performance and functionality.
You examine tools you can use to  Functional validation of code
analyze and validate your code.
Deployment In this lesson, you learn how to  Methods of deployment
develop different types of build
 Advanced application options
specifications depending on your
deployment requirements. You  Advanced installer options
also learn about the challenges  Shared library development
that can arise when deploying your
application for different types of  Source code distribution
targets and operating systems.  Additional build
specifications
 Comparison of deployment
processes

Advanced Architectures in LabVIEW

This advanced course discusses how to design and implement scalable, extensible
software architectures for large LabVIEW applications. Participate in discussions
and work independently and collaboratively to learn how to architect an application
and design components to support the architecture. Learn about several advanced
design patterns, reference architectures, inter-process communication methods, and
more. All instructors for this course are Certified LabVIEW Architects.
View the course outline | View a sample of the course materials

Course Objectives:
 Gain exposure to and experience with various architectures for medium to large
LabVIEW applications
 Learn how to select an appropriate architecture based on high-level requirements
 Recommended preparation for Certified LabVIEW Architect exam
Who Should Attend
Experienced LabVIEW users architecting medium to large applications
Prerequisites
LabVIEW Core 3 or experience programming medium to large LabVIEW applications
Course Overview
The Advanced Architectures in LabVIEW course discusses designing and
implementing scalable, extensible software architectures for large LabVIEW
applications. During the course, students participate in discussions and work
independently and collaboratively to learn how to architect an application and design
components to support the architecture. Students learn about several advanced
design patterns, reference architectures, inter-process communication methods, and
more.
After attending this course, you will be able to:
 Refine a requirements document and design a scalable, readable, maintainable,
and extensible software architecture for a large LabVIEW-based application
 Collaborate with a team to create an architecture
 Understand advanced design patterns and how to use them to implement the
components or subsystems of an architecture
 Evaluate various methods of communicating between multiple processes
 Understand the design trade-offs when selecting an advanced design pattern and
inter-process communication method
 Design a consistent, organized, and usable API
 Analyze, critique, and improve the architecture of a LabVIEW application
2. Course Outline
Lesson Overview Topics
Architecting an In this lesson, you learn how to design and  Characteristics of scalable, readable,
Application document scalable, readable, and maintainable architecture
maintainable software architectures.  Documenting a software architecture
 Characteristics of a scalable design
pattern
Designing an API In this lesson, you learn how to design a  API design techniques
consistent, organized, and usable API that
 Polymorphic VIs for an API
may reused in your software architectures
and distributed to several developers.  Project libraries for API design
 Passing data in an API
Multiple Processes In this crucial lesson, you learn about  Storing data, streaming data, and
and Inter-Process foundational APIs and design patterns and sending messages
Communication how they apply to several essential
 Foundational native LabVIEW APIs
advanced design patterns. You also learn
for messaging (queues, notifiers, user
several advanced methods for
communicating between multiple processes events, data value references)
and their tradeoffs. Exercises and tools are  Foundational design patterns (FGV,
general enough that you can use them in various state machines,
your own applications. producer/consumer, various queue-
driven message handlers)
 Scaling foundational design patterns
for multiple processes (e.g.
client/server)
 Asynchronous dynamic processes
 By reference inter-process data
storage (single element queues, data
value references)
  Several inter-process communication
methods
 Exposure to relevant native LabVIEW
APIs, advanced design patterns, and
reference architectures
Advanced User In this lesson, you learn how to create an  Subpanels
Interface Techniques architecture that provides a modular,
 XControls
scalable, and extensible user interface.
Introduction to In this lesson, you learn how using the  Introduction to LabVIEW classes and
Object-Oriented encapsulation and inheritance capabilities related terminology
Programming in of LabVIEW Object-Oriented Programming
 Using encapsulation to restrict access
LabVIEW can create very scalable and extensible
to class data
software architectures.
 Using inheritance and dynamic
dispatch to implement scalable
polymorphism at run time.
Plug-In In this lesson, you learn how to create a  Plug-in architecture using VI Server
Architectures plug-in architecture that allows you to add
 Plug-in architecture using LVOOP
features without changing your main code.
Tips, Tricks, and In this lesson , you learn various tips, tricks,  Variant attributes
Other Techniques and techniques to help create your
 Callback VIs with user events
architecture
 VI Scripting
 Drop In VIs

LabVIEW NXG Core 2: Create User-Driven Applications

The LabVIEW NXG Core 2 course is an extension of the LabVIEW NXG Core 1 course
and teaches you to create user-driven applications. You will be able to implement
parallel loops, programmatically respond to user interface events, and use proven
design patterns. You learn to manage configuration settings in configuration files,
develop an error handling strategy, and create standalone executables and packages
to distribute your application. This course directly links LabVIEW NXG functionality
to your application needs and provides a jump-start for application development.
View the Course Outline
Which course should I take: LabVIEW Core 1 or LabVIEW NXG Core 1?
Course Objectives:
 Implement multiple parallel loops and transfer data between the loops
 Create an application that responds to user interface events
 Implement robust user-driven applications using proven design patterns
 Manage configuration settings for your application
 Develop an error handling strategy for your application
 Generate execution logs in your application
Who Should Attend
New users and users preparing to develop applications using LabVIEW NXG
Prerequisites
LabVIEW NXG Core 1 or equivalent experience

After attending this course, you will be able to:

 Implement multiple parallel loops and transfer data between the loops
 Create an application that responds to user interface events
 Implement robust user-driven applications using proven design patterns
 Programmatically control user interface objects
 Manage configuration settings for your application
 Develop an error handling strategy for your application
 Generate execution logs in your application
 Prepare, build, and distribute stand-alone applications and packages

2. LabVIEW NXG Core 2 Course Outline

Lesson
Implementing Parallel Loops
Creating an Event-Driven User
Interface
Controlling the User Interface
Overview Topics
You will learn how to integrate  Implement parallel loops
multiple loops into a single  Share latest data between
application and transfer data loops using duplicate
between loops. terminals
 Stop parallel loops
 Stream every point of data
between loops using queues
 Identify and avoid race
conditions
You will learn how to create an  Event-driven programming
application that responds to user
 User interface event handler
interface events. You will learn a
design pattern
variety of event-driven design
patterns.  Event-driven state machine
design pattern
 Producer-Consumer (Events)
design pattern
 Queued Message Handler
design pattern
You will learn methods to modify  VI Server architecture
the attributes of front panel
 Using property nodes and
objects programmatically, such as
control references
temporarily disabling a control.
You learn how to use VI Server to
access the properties of front panel
objects
 Managing Configuration Settings You will learn how to store and
in an Application load configuration settings for
your application from a
configuration file.
Developing an Error Handling You will learn to develop a
Strategy strategy for how your application
responds to errors. You learn how
to analyze code for potential error
handling, test your error handling
logic, and implement various error
handling strategies.
 Manage configuration
settings
 Load configuration from a
delimited file
 Load configuration from an
INI file
 Error handling overview
 Inject errors for testing
 Handle specific errors locally
 Create execution log files

Distributing Code You will learn the process of  Preparing code for
creating stand-alone executables distribution
and package installers for
 Building an executable
LabVIEW NXG applications.
 Distributing an executable

Actor-Oriented Design in LabVIEW

Learn to use the Actor Framework to design and implement scalable, extensible
software architectures for LabVIEW applications requiring a high level of
concurrency. Participate in discussions and work independently and collaboratively
to design and build individual actors and to architect an application built with those
actors. Discover how to work in the framework, use inheritance and composition to
build highly parallel systems with rich behavior, and test and deploy completed
systems.
Course Objectives
 Build actors using the Actor Framework.
 Design and build complex, multi-actor systems to solve problems requiring a high
level of concurrency.
 Implement common design patterns in actor systems to promote reuse and
extensibility.
Additional Information
 The Actor Framework is intended for medium to large applications that have several user interface, data
acquisition, or data processing modules that run in parallel and must communicate with each other.
Who Should Attend
Experienced LabVIEW users who are designing medium to large applications that
require a high level of concurrency.
Prerequisites
LabVIEW Core 3 Object-Oriented Design and Programming in LabVIEW

After attending this course, you will be able to:

 Build actors using the Actor Framework.
 Design and build complex, multi-actor systems to solve problems requiring a high
level of concurrency.
 Implement common design patterns in actor systems to promote reuse and
extensibility.

Actor-Oriented Design in LabVIEW Course Outline

Lesson Overview
Actor Framework: Fundamentals This lesson introduces the Actor
Framework and describes the
development challenges that it
helps to solve. You will learn
about the parts of the Actor
Framework.
Creating Actors This lesson describes the process
for creating new actors.
Topics
 The Challenge of Concurrency
 Introduction to Actor Design
 The Actor Framework
 Creating an Actor
 Creating UIs, Part 1: Using
Control References
 Using the Time Delay
Message
 Using Static Nested Actors
 Adding Helper Loops
 Error Handling Basics
 Using Dynamic Nested Actors
 Creating UIs, Part 2: Using
Events
 Using Last Ack to Manage
Nested Actors
Introduction to the Course Project This lesson introduces the course
project. You will discuss several
possible design approaches for
solving that problem.
Building Actors Through This lesson describes how you can
Inheritance use inheritance to implement
complex behavior in a single actor.
Hardware Abstraction Layers This lesson introduces the concept
of the hardware abstraction layer
(HAL). You will learn the value of
using a HAL in your development
and how to implement a HAL
using the Actor Framework.
Building Actors Through This lesson describes how you can
Composition design an actor that uses other
actors to implement complex
behavior.
Zero Coupling and Abstract This lesson describes how you can
Messages send messages from a nested actor
to its caller without knowing
anything about the caller.
Designing User Interfaces This lesson defines two options for
creating user interfaces in the
Actor Framework. You will learn
to select and implement the best
option for the problem at hand.
Distributed Systems This lesson presents how to design
actors for use in distributed
systems.
State Pattern Actors This lesson describes the state
pattern and how you can
implement the state pattern using
the Actor Framework.
Advanced Message Handlers This lesson introduces techniques
that change how actors handle
messages. You will learn when to
consider using each technique.
Actors in Synchronous Systems This lesson presents several
techniques for integrating actors
into a synchronous system.
Automated Testing This lesson describes how to
design a test harness to perform
automated testing on an actor.
 Description of the Challenge
 Solving the Design Challenge
with Traditional LabVIEW
 Building Actors Through
Inheritance
 What is a HAL?
 Implementing a HAL
 Building Actors Through
Composition
 What is Zero Coupling?
 Using Abstract Messages
 Adding a UI Through
Inheritance
 What is Low Coupling
 Implementing a UI based on
Model-View-Controller
 Connecting Actors to FPGA
Code
 Connecting Actors on
Multiple Targets
 Managing UIs for Multiple
Subsystems
 What is the State Pattern?
 Managing State in LabVIEW
 Managing State in Actor
Framework
 Creating Message Filters
 Redirecting Messages
 Generating Custom Trace
Events
 What is a Synchronous
System?
 Calling an Actor from a
Synchronous Environment
 Using Reply Messages
 Automated Testing
 Wireless Prototyping Fundamentals using NI SDR and LabVIEW
Communications System Design Suite
The Wireless Prototyping Fundamentals course introduces you to rapid prototyping of wireless
systems with the LabVIEW Communications System Design Suite. You will learn how to navigate the
LabVIEW Communications environment, including the panel, diagram, system designer, projects, and
design languages. In this course, you will follow a typical design flow to design an algorithm and define
the system architecture. You will perform analysis and profiling and then convert a floating point
algorithm to fixed point before compiling and deploying it to the FPGA. At the end of this course, you
will have a working OFDM transceiver.
Course Objectives:
 Use the NI Software Defined Radio platform for wireless prototyping using the LabVIEW
Communications
 Design and run algorithms on the processor using the LabVIEW G, MathScript and C languages
 Design and run algorithms on the FPGA using the Multirate Diagram, FPGA IP, and Clock Driven
Logic contexts
 Implement data transfer and communications methods to exchange data between the processor
and FPGA
 Select the most appropriate language to begin your design based on algorithm requirements and
structure
 Quickly design new communications systems and/or evaluate new wireless algorithms using real-
world signals
Who Should Attend
Communications algorithm designers who need to prototype next generation wireless communications
systems or Engineers using software defined radio for rapid prototyping of wireless communication
systems
Prerequisites
Knowledge of basic digital communications concepts
After attending this course you will be able to:
Quickly design new communications systems and/or evaluate new wireless algorithms using real-
world signals.
 Design and run algorithms on the processor using the LabVIEW G, MathScript and C languages
 Design and run algorithms on the FPGA using the Multirate Diagram, Optimized FPGA VIs, and
Clock Driven Logic contexts
 Implement data transfer and communications methods to exchange data between the processor
and FPGA
 Select the most appropriate language to begin your design based on algorithm requirements and
structure
 Quickly design new communications systems and/or evaluate new wireless algorithms using real-
world signals

Wireless Prototyping Fundamentals Course Outline

Lesson Overview Topics
Wireless This lesson introduces the NI Software-Defined  Introduction to Wireless
Prototyping Radio platform for wireless prototyping using the Prototyping Methodology
LabVIEW Communications design environment. You  Introduction to LabVIEW
learn the challenges facing the wireless industry and Communications
some solutions for overcoming them. You explore the  Hardware Architecture
LabVIEW Communications environment and  Project Environment
identify the components of a system architecture.
Building a VI In this lesson you learn how to build a VI in  Components of a VI
LabVIEW Communications. You also learn
 Objects on the Panel
about the tools to debug your VI and the text-based
languages that are supported in the LabVIEW  Objects on the Diagram
Communications environment.  Text-Based Design language
 Structures
 SubVIs
 VI Debugging
Data Transfer and In this lesson, you discover how to use the Data pane  Data Pane
Communication to store, retrieve, view, and analyze data. You
 File and Folder Paths
also learn the tools to programmatically create files
and folder paths.
Programming in This lesson covers best practices when programming  Parallel Loops
Parallel in parallel loops. You practice using duplicate
 Duplicate Terminals
terminals and queues to communicate data between
loops.  Queues
 FPGA This lesson provides an overview of the different  Introduction to FPGA
Programming with design languages for FPGA. You learn the benefits
 Using FPGA VIs
LabVIEW and limitations of each language and how to select
the language to use for a given scenario.  FPGA Host Interface
 Data Transfer with FIFOs
Multirate Diagram This lesson explores the Multirate Diagram in more  Using Multirate Diagrams
and FPGA detail and covers the ways in which it helps you
 Converting Floating-Point to
iterate more quickly on your algorithm design.
Fixed Point
 Integrating Multirate
Diagrams with FPGA VIs
Using In this lesson, you learn to use the time-saving and  Overview of the Directed
Optimized FPGA project-specific properties of Optimized FPGA VIs. Optimization of FPGA VIs
VIs
 Optimized FPGA VI vs.
Multirate Diagram
 Optimized FPGA VIs in
Other Document Types
Designing with This lesson explains basic digital design theory and  Clock-Driven Logic and
Clock-Driven Logic how to use data transfer and storage tools for Quality of Results
synchronization. You learn the different
 Using FIFOs with Clock-
considerations for timing a digital signals, the reason
Driven Logic
to use FIFOs with clock-driven loops, and the purpose
of handshaking.  Handshaking
 Host API
Advanced Tips and This lesson presents some best practices for  Using Xilinx IP
Tricks incorporating third-party FPGA tools and ensuring a
 Specialized Nodes
successful compile.

LabVIEW Performance
Take the next step in writing better code with this hands-on course, which helps you
identify and improve performance issues with your NI LabVIEW code. Also learn how
to design your code to avoid common performance pitfalls. During the course, choose
the appropriate tools to measure application performance. After identifying
performance issues, learn to modify code to improve memory usage and/or execution
speed.
Course Objectives:
 Learn how to identify and improve performance issues
 Create applications that better use memory, threads, and I/O
 Design applications for optimal performance based on application requirements
Who Should Attend
Engineers who need to improve performance and optimize their LabVIEW code
Prerequisites
LabVIEW Core 1 and 2 or experience programming small to medium LabVIEW
applications
After attending this course, you will be able to:
 Describe how software and hardware interact and contribute to performance
 Design applications for optimal performance based on application requirements
 Select the appropriate tools to monitor application performance
 Identify performance issues in an existing application
 Modify existing applications to improve memory usage
 Modify existing applications to improve execution speed

Course Outline
Lesson Overview Topics
Defining Performance This lesson introduces the basics of  Overview of Performance
performance in relation to computer  Computer Resources
hardware and software. You also learn the  Resource Management
basics of computer architecture and how
system components affect performance.
Designing Your Application In the lesson, you learn how to design an  Managing CPU
application to avoid resource bottlenecks.
 Managing Memory
 Managing Disk Memory
 Managing Threads
 Managing I/O
Measuring Performance This lesson introduces various tools for  Indentify the Bottleneck
measuring application and system
 Tools for Measuring
performance. From these tools, you will be
Performance
able to select the appropriate tool for
measuring and identifying performance  VI Profiler
issues.
 Performance
Benchmarking
 VI Analyzer Toolkit
 Desktop Execution Trace
Toolkit
 Optimizing for Memory In this lesson, you modify existing  Memory Buffers
applications to improve memory usage.
 Inplaceness
 Memory Reallocation
 Memory Cleanup
Optimizing for Execution In this lesson, you modify existing  Updating the UI
Speed applications to improve execution speed.
 Event Structure and UI
Events
 Parallel Code
 Simplifying Code

LabVIEW Connectivity
Build on the information you learned in the NI LabVIEW Core 3 course. Identify the
components of integrated systems and implement networking technologies for your
applications. Also extend your application functionality and reduce development time
by using technologies such as DLLs, ActiveX, and the Internet to take advantage of
the capabilities of other applications.
Course Objectives:
 Identify the components, benefits, and use cases of different network
communication options
 Design applications using different networking technologies and architectures
 Programmatically control LabVIEW VIs and applications using VI Server
 Share data between LabVIEW and other applications over a network
 Use the LabVIEW Database Connectivity Toolkit to communicate with databases
Who Should Attend
Engineers wishing to extend the functionality of LabVIEW applications through
network technologies
Prerequisites
LabVIEW Core 2 or experience programming small to medium applications in
LabVIEW
After attending this course, you will be able to:
 Identify the components, benefits, and use cases of different network
communication options
 Design applications using different networking technologies and architectures
 Programmatically control LabVIEW VIs and applications using VI Server
 Share data between LabVIEW and other applications over a network
 Create and deploy Web services using LabVIEW
 Use the LabVIEW Database Connectivity Toolkit to communicate with databases
 Use LabVIEW with ActiveX and .NET
 Use DLLs with LabVIEW
 Use UDP and TCP/IP VIs to communicate with other applications locally and over
a network

Course Outline
Lesson Overview
Calling Shared Libraries in LabVIEW This lesson introduces how to use
LabVIEW to call code written in other
languages. You learn how to use the Call
Library Function Node to call Dynamic
Link Libraries (DLL) on Windows.
Using VI Server VI Server is an object-oriented, platform-
independent technology that provides
programmatic access to LabVIEW VIs.
This lesson describes how to access the VI
Server through block diagrams, ActiveX
technology, and the TCP protocol to
communicate with VIs and other
application instances so you can
programmatically control VIs and
LabVIEW.
Using .NET and ActiveX Objects in This lesson describes how to extend your
LabVIEW application functionality by accessing
other Windows applications using .NET
and Active X technologies and event
programming.
Topics
 Shared Libraries Overview
 Calling Shared Libraries
 Using the Import Shared Library
Wizard
 Capabilities of the VI Server
 VI Server Programming Model
 VI Server Functions
 Remote Communication
 Dynamically Loading and Calling
VIs
 Using .NET Objects in LabVIEW
 Implementing .NET in LabVIEW
 Registering .NET Events
 Using ActiveX Objects in LabVIEW
 Using LabVIEW as an ActiveX
Client
  Using LabVIEW as an ActiveX
Server
Connecting to Databases This lesson defines database terminology  What is a Database?
and demonstrates database
 Database Standards
programming in LabVIEW.
 Connecting to a Database in
LabVIEW
 Performing Standard Database
Operations in LabVIEW
 Structured Query Language
Using UDP and TCP for Network This lesson describes using User  UDP Overview
Communication Datagram Protocol (UDP) as a means for
 Implementing Broadcast Models\
communicating short packets of data to
one or more recipients on a network and  TCP Overview
implementing the broadcast model in  Implementing the Client/Server
LabVIEW.
Model
Additionally, this lesson describes how to
use TCP/IP to communicate and share
data over single and interconnected
networks. You learn to create diverse
systems that share information using the
Client/Server model of networked
applications.
Using LabVIEW Web Services This lesson introduces LabVIEW Web  Web Services Overview
Services and teaches how to use
 LabVIEW Web Service Architecture
LabVIEW to provide a standard Web-
based  Creating HTTP Method VIs
interface for communication with a  LabVIEW as an HTTP Client
LabVIEW application. You learn how to
use LabVIEW as both a client and server  LabVIEW Web Service Security
for your Web service.

Using LabVIEW and TestStand in Regulated Industries

As product complexity increases and development time compounds, software
engineering processes grow even more important to the success of any test and
automation project. In addition, regulatory requirements, such as those in the
medical device industry, demand efficient and reliable development processes to
address safety, business, and regulatory risk considerations. Taught by experts in the
medical device regulatory space and NI products, this course helps learners navigate
regulatory requirements and business demands when using LabVIEW for test and
automation for medical devices. This course examines FDA regulatory requirements
and delivers best practices for reducing the burden commonly felt during computer
software validation and test method validation activities.
Course Objectives
 Validate LabVIEW applications
 Make strategic design decisions to minimize the impact of validating and
revalidating LabVIEW applications
 Implement process improvements and best practices to increase the rigor of
validation yet decrease the pain associated with validation

Who Should Attend

Design verification engineers, manufacturing test engineers, and people on Software
Quality or Design Assurance teams who review code written in LabVIEW or
TestStand.
Prerequisites
Basic understanding of LabVIEW and the environment. LabVIEW programming
experience is not essential for this course, but helpful. Some familiarity with FDA
regulations and rigors of working in the medical device industry or other highly
regulated industry.
After attending this course, you will be able to:

 Validate LabVIEW applications

 Make strategic design decisions to minimize the impact of validating and
revalidating LabVIEW applications
 Implement process improvements and best practices to increase the rigor of
validation yet decrease the pain associated with validation

Using LabVIEW and TestStand in Regulated Industries Course Outline

Lesson Overview Topics
Regulatory Landscape This lesson discusses the history,  FDA History and Mission
purpose, and aim of the Food and  Safety and efficacy
Drug Administration  Paths to market
(FDA). Smart, pain-free  FDA enforcement powers
regulatory compliance starts with
understanding the agency and
why they promulgate the
regulations you must follow.
The Quality System: 21CFR820 and In this lesson you will learn about  21CRF820 and ISO13485
ISO13485 United States and European
 Testing scenarios during the
Quality System Regulations and
product life cycle
which parts apply to you as a test
engineer.  Deep dives into targeted
regulations
Risk Management Everything traces back to safety  Risk to whom?
and efficacy. This lesson takes an
 Finding and quantifying risk
in-depth look at risk.
 Controlling and managing
risk
21CFR820.70(i) and Software Software that automates the  Validation vs. verification
Validation quality system or the
 DQ/IQ/OQ/PQ
manufacturing process shall be
validated to an intended use.  Validation planning and
execution
Change Management and
Revalidation
21CFR820.72 and Test Method
Validation
21CFR11 and Good Documentation
Practices
Automate DQ with VI Analyzer,
Execution Trace, and LabVIEW
Compare and Merge Tools
Automate IQ with Object-Oriented
Programming and a Hardware
Abstraction Layer (HAL)
Automate OQ with LabVIEW Unit
Test Framework
Good Tester Design Minimizes PQ
Change will happen. Revalidation  Software change control
does not have to be overly
 Impact assessment
burdensome.
 Targeted revalidation
This lesson describes how test  What is Test Method
method validation can be Validation (TMV)?
encompassed by the software
 Instrument specifications
validation activity or in some cases
avoided by clever design.  Leveraging the calibration
process
The dreaded 'Part 11’ is  Good Documentation
applicable. But it is not something Practices
to fear. This lesson demystifies  GDP and Part 11
Part 11 and gives tactical advice  ‘Predicate Rules’
on how to meet Part 11 head on.  Making Part 11 simple
In this lesson, you learn how to  Source code control
streamline Design Qualification  LabVIEW compare and merge
activities and take credit for good tools
software development processes.  Coding standards and code
reviews
 VI Analyzer verifies design
rules
 Desktop Execution Trace
Toolkit supports DQ
Installation Qualification can be  Decouple application layer
costly if repeated often. Minimize from hardware with a HAL
tester downtime with easy to
 Hallmarks of a good HAL
automate IQ protocols.
 Automating IQ with a HAL
Let LabVIEW work for  What is unit testing?
you. Writing code is only part of
 Automate the Validation
the job. Validating your software
Protocol
is as important and can take over
twice the time. Learn how to  Validate your HAL with the
streamline validation and LabVIEW Unit Test
revalidation with the LabVIEW Framework
Unit Test Framework.
 Verify child class plugins with
the LabVIEW Unit Test
Framework
Performance Qualification can be  Revisit TMV
minimized by selecting the correct
 Can calibrate accuracy but
instrumentation and using it as
not precision
intended.
 Mitigate Human Error
 GR vs GR&R
 PQ
 Instrument Suitability
Assessment
Trace Matrix with Requirements Do the work up front and generate  How to apply selected
Gateway your trace matrix with the push of TestStand tools and concepts
a button. to meet FDA regulations
What is TestStand? This lesson examines TestStand  Sharing data between
and emphasizes key concepts from deterministic and non-
the NI TestStand training deterministic processes
courses. These concepts are
reexamined under a regulatory
 Sharing data between non-
compliance lens. deterministic processes.
How TestStand Makes Validation Let TestStand do the heavy lifting  Streamline DQ with the
Easier so you can focus on writing your TestStand Sequence Analyzer
test. Certain TestStand and File Diff and Merge
customizations are commonly Utility
found across many
industries. This lesson walks  Validating TestStand
through example validations of customizations
TestStand architectures  21CFR820.70(i) as it applies
commonly found in the field. to testing processes
 21CFR11
 Tying it all together