LabVIEW Core 2 Course Outline

2010 Schedule:

February, 22 - 23
May, 24 - 25
August, 23 - 24
November, 22 - 23

Outline:

This is a two day course that, like LabVIEW Core 1, is aimed at new or casual LabVIEW programmers.
The LabVIEW Core 2 course teaches you to design complete, stand-alone applications with LabVIEW.
This course is an extension of the LabVIEW Core 1 course and introduces you to common design techniques for successfully implementing and distributing LabVIEW applications for research, engineering, and testing environments.
Topics covered include the use of event-driven programming, programmatic control of your user interface, techniques to optimize reuse of existing code, use of binary file I/O functions, and error handling practices.
This course directly links LabVIEW functionality to your application needs and provides a jump-start for application development.

After attending this course, you will be able to:

Apply common design patterns that use notifiers, queues, and events
Use event programming effectively
Programmatically control user interface objects
Evaluate binary file I/O formats and use them in applications
Optimize reuse of existing code for your projects
Use the LabVIEW Application Builder to create executables and installers to distribute applications

Where:

Training Room
ICON Technologies
Suite 8, CSG Building
3 Sarich Way
Technology Park
Bentley WA 6102

Prerequisites:

Experience with Microsoft Windows
LabVIEW Core 1 or LabVIEW Basics I, or equivalent experience

Day-By-Day Topic Outline:

Day 1

Common Design Techniques
This lesson introduces you to design patterns. You will 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. Topics include:
• Design patterns
• Single loop design patterns – simple VI, general VI, and the state machine design patterns
• Multiple loop design patterns – parallel loop, master/slave, and producer/consumer design patterns
• Timing a design pattern

Synchronization Techniques
This lesson describes techniques for transferring data between multiple loops using notifiers and queues. You learn how notifiers and queues have advantages over using variables. Topics include:
• Variables
• Notifiers
• Queues

Event Programming
This lesson describes event-driven programming using the Event structure and design patterns that use the Event structure. Topics include:
• Events
• Event-driven programming
• Caveats and recommendations
• Event-based design patterns

Error Handling
This lesson describes the importance of incorporating error handling in your applications. You learn how to ensure that you are detecting and reporting all possible warnings and errors that might occur in your application. You learn how to create and use an error handler VI. Topics include:
• Importance of error handling
• Errors and warnings
• Ranges of error codes
• Error handlers

Day 2

Controlling the User Interface
This lesson describes methods to control the attributes of front panel objects programmatically such as making an object invisible until a certain point in the execution of the program. You will learn how to use VI Server to access the properties and methods of front panel objects. Topics include:
• Property nodes
• Invoke nodes
• VI Server architecture
• 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. Topics include:
• File formats
• Binary files
• Technical data management streaming (TDMS) files

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. Topics include:
• Refactoring inherited code
• Typical issues when refactoring code
• Comparing VIs

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. Topics include:
• Preparing the files
• Build specifications
• Building the application and installer

Fee:

In accordance with National Instruments LabVIEW training fee structure.

We offer a specially priced LabVIEW Cores 1 and 2 Training Bundle at $3450 (tax-ex).

This Bundle includes LabVIEW Core 1 Training (3 days) and LabVIEW Core 2 Training (2 days).
The Bundle also includes the examination fee for the Certified LabVIEW Associate Developer Exam, comprehensive manuals, a certificate, and lunch and morning and afternoon tea each day.
This Bundle represents excellent value.
The scheduled course fees if you choose to do the LabVIEW Core 1 and LabVIEW Core 2 Training Courses separately are $2785 (tax-ex) and $1815 (tax-ex) respectively.