1

NI CertificationCertified LabVIEW DeveloperExam Preparation Course

2

Purpose Of This Course

•Prepare you to take the certification exam by:•Reviewing the Certification & Examination Process•Discussing the Topics of Often Missed Questions•Showing Examples of Good Wiring Techniques •Demonstrating Good VI Construction Techniques

Essentially a Collection of Topics and Tips for Taking the Certified LabVIEW Developer Examination

3

Purpose Of This Course

• This course will not give you the questions on the exam, however:

•The topics presented are aimed at the most often missed questions

•The answers to these often missed questions are part of the presentation

4

Schedule of Topics

•Certification Process•Examination Process•Written Examination Topics of special concern•Practical Examination topics of special concern

•VI Construction•Wiring Techniques

5

Benefits:• Use of National Instruments Certification Logo

• Listing on ni.com/training

6

Certification ProcessThe Process ensures:

•Credibility - Fair and Unbiased => Value!•Validity - It Evaluates Important items•Reliability - A Reliable Indicator of Proficiency

7

Certification Process•The Candidate Submits an Application

•The Candidate Takes the Examination

•The Examination is Graded

•Every Examination is Reviewed by at Least Two People

•Ensures Objective Results

•The Candidate Receives a Certificate and Logos

•The Candidate’s Name is Placed on ni.com

8

CLD Examination Details•Two parts: •Written

•Written contains 40 Questions •90 Minute Time Limit•All Multiple Choice Questions

•Practical contains One Project: •Time Depends on Which Exam is provided•Usually 3 ½ to 4 ½ hours

9

CLD Examination DetailsWritten Examination InstructionsCertified LabVIEW Developer Examination

Examinee ____________________________________________ Date: ____________Administrator _________________________________________ Date: ____________

Instructions:There are two sections in this examination. The first section is a set of forty multiple choice questions. The second section is a hands-on project creating a VI that conforms to a set of specifications.Questions 1 through 31 each have one correct response. Questions 33 through 40 have one or more correct choices, and all correct responses must be selected to get credit for that question. You are not allowed to ask the proctor for help. If you believe the intent of a question is not clear, you may note that question, and your reasons for choosing the answer you believe best fits the question. Your comments will be taken into account and credit awarded appropriately when the exam is graded.Each multiple choice question is worth 1.5 points, for a total of 60 points. The project is worth 40 points. The entire examination is therefore worth 100 points. The minimum passing grade is 75%. In addition to the total score, the written and practical components must each receive a passing grade as separate components.This examination may not be taken from the examination area or reproduced in any way. A computer with LabVIEW is the only reference allowed for the examination. The time limit for Section 1 is 90 minutes. The time limit for Section 2 is stated in that section.

10

CLD Examination DetailsTypical Exam Question ConstructionObjective:Describe the following options available on Front Panel Controls and Indicators

•Visible Items•Make Current Value Default•Reinitialize to default•Synchronous Display•Enabled State•Autoscale

Exam Question:Which of the following options determines whether a user can update a Front Panel Control’s value?a.Autoscaleb.Enabled Statec.Synchronous Displayd.Make Current Value Default

11

CLD Examination DetailsPractical Examination InstructionsIntroduction:Your company has received a contract to produce a ----------- system for a local manufacturer. The purpose of the ----------- system is to monitor the ------------- manufacturing --------------- to ------------- ----------- -------------- ------------- -----------.You have been assigned to create the software for this system using LabVIEW. You will create the software for six ------------- ------------, with the actual hardware being simulated by Boolean switches on the Front Panel.

Requirements:Using a front panel similar to the graphic provided, create a VI that implements the ---------- system requirements listed in this section. All hardware components are to be simulated using LabVIEW controls and indicators. Your solution must consist of code created expressly for this exam using VIs and functions directly available in LabVIEW.Your solution should be hierarchical in nature. All major functions should be performed in SubVIs.The solution should not use 100% CPU time while running, and should respond to any front panel control change, including “Stop Simulation,” in less than 100mS.The resulting VI must be presented to the proctor in two forms. Recommended forms are 3 ½ inch floppy disk, CD-R, or email to mike.fillian@ni.com.

12

Practical Exam Grading

• Practicals are graded on three criteria:– Functionality– Programming Style– Documentation

• Each of these criteria have approximately equal weights• The Practical must be passed independent of the written

portion of the exam• Total practical grade is 40% of composite grade

13

Functionality

• Does the VI properly perform the requirements listed in the specifications?– Is the logic correct for Boolean inputs and outputs?– Does the VI respond to user inputs within the stated time limit?

14

Style

• Is the VI constructed in a professional manner?– Easily maintainable?– Constructed for scalability?– Does it use unnecessary Variables?– Does it improperly use Property Nodes?– Are there unnecessary structures?

• Sequence Structures– Does it use 100% CPU time?– Logical layout with edges lined up

Run Property Node Example

15

Documentation

• Wire data – If the data flowing through a wire is not clear, a specific label should

indicate the purpose of that data• Function of code segments

– Segments of code should have labels describing the function of that code

• Controls and indicators have descriptive names• Standard labels are yellow (found on String SubPalette)

16

Written Examination Topics

David BonalCourse Development Engineer

17

LabVIEW Topics

• Booleans• Memory• Multithreading• Property Nodes• Variables

t

• DLL• ActiveX• VI Server• Synchronization

Nine Areas of Concern

18

LabVIEW Topics

• Booleans• Memory• Multithreading• Property Nodes• Variables

t

• DLL• ActiveX• VI Server• Synchronization

Nine Areas of Concern

19

Booleans• Many programmers do not understand the

functionality of mechanical action of booleans• Switch action:

Control is toggled

until changed by

hand

• Latch action:

Control reverts to

default state when

read by diagram

20

Booleans

• Where to get help:

Help>>Find Examples>>Building User Interfaces>>General>>Mechanical Action of Booleans

21

LabVIEW Topics

• Booleans• Memory• Multithreading• Property Nodes• Variables

t

• DLL• ActiveX• VI Server• Synchronization

Nine Areas of Concern

22

Memory

• The most common and most mysterious reason for

poor performance of VIs

• LabVIEW handles memory management

automatically

– No need to code when to allocate or deallocate

– You have less control over when memory operations occur

23

Memory VI Component Memory Usage

• Data is always loaded• Code is loaded if platforms match

(MacOS, Windows, Sun, Linux)• Panel and Diagram are loaded if needed (recompiling)

Main VI SubVI

Always in memory

Resident sometimes

FrontPanel

BlockDiagram

Code DataSpace

FrontPanel

BlockDiagram

Code DataSpace

24

MemoryCoercion and Consistent Data Types

•Coercion dots imply a conversion of data types

•In general, the compiler creates a new buffer to store the converted data

•Affects performance

25

MemoryCoercion and Consistent Data Types

Method 1 (Incorrect) Method 2 (Incorrect)

Method 3 (Correct)

4 kB for copy to SGL8 kB

8 kB4 kB for FP copy

8 kB

8 kB4 kB to convert

to SGL

4 kB to convert to SGL

4 kB for FP copy

4 kB

4 kB

4 kB for FP copy

24 kB total 28 kB total

12 kB total

26

MemoryBuilding Arrays

Terrible Method

27

MemoryBuilding Arrays

Slightly Better Method

28

MemoryBuilding Arrays

Good Method

29

MemoryBuilding Arrays

Best Method

30

LabVIEW Topics

• Booleans• Memory• Multithreading• Property Nodes• Variables

t

• DLL• ActiveX• VI Server• Synchronization

Nine Areas of Concern

31

Multithreading

• Specific tasks within an application are subdivided• Provides “pseudo-parallelism”• Threads are automatically handled in LabVIEW• Seven execution systems• Five available priorities

Overview

32

Multithreading

VI

User Interface

StandardInstrument

I/OData

AcquisitionOther 1 Other 2

Same as Caller

LabVIEW

Operating System2000/NT/9x, Sun Solaris 2, and Linux

Architecture

33

Multithreading

• Priorities control when a VI is executed within the thread

• Five priorities– Background– Normal– High– Time Critical– Subroutine

Priorities

36

Multithreading

Issues

•SubVI calls are relatively expensive•Calling a subVI in a different execution system can be really expensive•Biggest issue = THREAD SWAPS

Multithreading Demonstration

37

Multithreading

• Deadlock occurs if each thread is requesting a resource held by the other

Issues - Deadlock

Resource A

Thread 1

Thread 2

Resource B

LocksRequested and Waiting

LocksRequested and Waiting

39

MultithreadingIssues – Priority Inversion•A high priority task is requesting a locked resource from a low priority task, causing a lower priority task to gain more CPU time

Time

Prio

rity

High

Low

Thread 1

Thread 2

Thread 3

Running

Blocked

Waiting

Locks Resource

Locks Resource

Resource Unavailable

40

LabVIEW Topics

• Booleans• Memory• Multithreading• Property Nodes• Variables

t

• DLL• ActiveX• VI Server• Synchronization

Nine Areas of Concern

41

Property Nodes

• Properties are characteristics or qualities about an object• Property nodes allow you to programmatically set and

read the properties of front panel objects, including an object’s data value

• Examples of properties:

Overview

•Display colors of front panel objects•Visibility of front panel objects•Menu selections for a ring control

•Scales and cursors on graphs•Size of front panel objects•Location of front panel objects

42

Property NodesCreating Property Nodes• Right-click on a panel object or its diagram

terminal and choose Create»Property Node

• Use the Operating tool to select which property to read or write

43

Property Nodes

• Very fast to program, very slow to execute• Difficult to debug• Violates data flow programming• Property nodes located in a subVI will load the front panel into memory

• Property nodes cause a thread swap to the User Interface thread

• Property nodes execute serially, never in parallel

Issues

44

Property Nodes

• When performing multiple control property changes on a graph, use “Defer Panel Updates”– Disables UI refresh until the property changes are complete

Defer Panel Updates

45

Property Nodes

• Refnum to a specific front panel object• Allows you to control front panel objects with a subVI

Control References

Control References Demonstration

46

LabVIEW Topics

• Booleans• Memory• Multithreading• Property Nodes• Variables

t

• DLL• ActiveX• VI Server• Synchronization

Nine Areas of Concern

47

Variables

• Use local variables to access front panel objects from more than one location in a single VI

• Pass data between block diagram structures that you cannot connect with a wire

Local Variable Overview

48

Variables

• Used to pass data among several VIs• “Pseudo-VI” without a block diagram• Multiple objects can be placed into one global

Global Variable Overview

Create the controls needed as global variables

Each control must have owned label

Right-click using the Operating Tool

49

VariablesRace Conditions

LabVIEW Code Sequential Codex = x * 5x = x + 2

ORx = x + 2x = x * 5

No clear data dependency exists, so the order of execution is not precisely known

50

Variables

• Each control or front panel object must have an owned label associated with it

• Difficult to debug• Contributes to race conditions

Issues

51

LabVIEW Topics

• Booleans• Memory• Multithreading• Property Nodes• Variables

t

• DLL• ActiveX• VI Server• Synchronization

Nine Areas of Concern

52

Dynamic Link Libraries (DLL)Overview• An executable file that can never run on its own• Loaded by operating system as requested by

application• Application uses dll code as part of its binary files• Application does not know what language dll was

originally written in• Dll acts like a ‘black box’ with exported functions• Application need not know how these functions are

actually implemented

53

DLLCall Library Function

Thread-UnsafeRuns in User Interface Thread(Orange)

Thread-SafeRe-entrantCall Library Node(Yellow)

54

DLL Issues

• LabVIEW loads the DLL at the same time the VI is loaded

• LabVIEW unloads the DLL when the calling VI has been completely removed from memory

• Thread safe DLLs• Global variables or initialization code located in DLL

55

DLL Issues

Suppose we have the following DLL:/* Global Variable */int test = 0;

/* Function to be exported */__declspec (dllexport) void __stdcall secondLevel(int *value){

test = test + 15;*value = test;

}

Called with the following LabVIEW Code:

56

DLL Issues

• We expect the DLL to return 15• The DLL actually returns:

Continued

Run Output

1 15

2 30

3 45

58

LabVIEW Topics

• Booleans• Memory• Multithreading• Property Nodes• Variables

t

• DLL• ActiveX• VI Server• Synchronization

Nine Areas of Concern

59

ActiveX

With ActiveX automation, you can:

• Create applications that expose objects - called automation servers.

• Create and control objects exposed in one application from another application - called an automation client.

Overview

An automation object can have:

• Methods - Functions that perform an action on an object, such as resizing it.

• Properties - Functions that set or return information about the state of an object.

60

Opens an automation refnum that refers to a specific ActiveX Automation object

Invokes a method or action on an ActiveX automation object

Sets or gets ActiveX object property information

Closes an automation refnum. To prevent a memory leak close open automation refnums

ActiveX VIs

61

ActiveXExample

62

ActiveX

• Information about the server• Closing the refnums to prevent memory leaks

Issues

63

LabVIEW Topics

• Booleans• Memory• Multithreading• Property Nodes• Variables

t

• DLL• ActiveX• VI Server• Synchronization

Nine Areas of Concern

64

VI ServerOverview

• Provides programmatic access to LabVIEW and its Applications (your programs)– Call a VI remotely.– Allows you to control a LabVIEW application from another

program.– Update the properties of multiple VI’s.– Edit the properties of a VI and LabVIEW– Load VIs into memory dynamically– Create a plug-in architecture– Retrieve LabVIEW and platform information.

65

VI Server

VI Server

ActiveX Interface

Diagram Functions

TCP/IP

ActiveX AutomationClient

TCP/IPClient

Architecture

66

VI Server

• Two classes of objects- Application—just one per LabVIEW application

- Virtual Instruments

• Each class offers:- Properties—single valued attributes of the object:

read/write, read only, write only- Methods - functions that operate on the object

Objects

67

VI ServerExample

Open Application is only needed if accessing a VI on a remote machine

VI path can be a pathname, or a string

Property Node opens the front panel of the VI

Invoke Node calls the Method ‘Run VI’

Close the session

Check for errors

Open a session to a VI object

68

VI ServerStrictly Typed VI Refnum

A data type that encodes the connector pane type information, but not the VI to call.

Open VI Reference function

Call By Reference

Connector type and VI information

Connector pane type and VI to call

69

VI ServerAdvantages of a Strictly Typed VI Refnum

Using Methods to Write/Read Controls/Indicators

•Same thing using Call by Reference

•Much neater diagram

•Datatypes checked by Open VI Reference

•No type checking when VI called (Strong Typing)

Flatten to String Unflatten from String

70

LabVIEW Topics

• Booleans• Memory• Multithreading• Property Nodes• Variables

t

• DLL• ActiveX• VI Server• Synchronization

Nine Areas of Concern

71

Synchronization

• Powerful, easy to use, underused features• Five Types:

– Occurrences– Notifiers– Queues– Semaphore– Rendezvous

Overview

72

SynchronizationOccurrences

• Software interrupt• Efficient

73

SynchronizationOccurrences - Example

74

SynchronizationNotifiers

•Function like occurrences, but with the added feature of passing data•Area of concern – Notifiers can lose data

75

SynchronizationNotifiers - Example

76

SynchronizationQueues

•Function like notifiers, but retain the data in a FIFO buffer•A non lossy synchronization technique

77

SynchronizationQueues - Example

78

SynchronizationSemaphore

• Protects access to shared resources• Can be used to avoid race conditions

79

SynchronizationSemaphore - Example

80

SynchronizationRendezvous

•Used to synchronize multiple tasks•Allows for parallel tasks to wait for each other before proceeding

81

SynchronizationRendezvous - Example

82

Questions?

83

Practical Examinations

84

About the Practical

• A PC with LabVIEW is required• LabVIEW Help may be used

– You are not allowed to plagiarize shipping examples!

• No other resources are allowed

• Time varies a small amount based on the requirements– Generally 3 ½ to 4 ½ hours

85

The Intent of the Practical

• The practical evaluates overall LabVIEW Programming skills

• What is required:– Good LabVIEW programming techniques– Problem solving skills in LabVIEW– Good Programming Style

• Must have mastery of these skills to complete the exam in the time allotted

86

Example: 4-Way Intersection Traffic Lights

• Green-Yellow-Red for:– Northbound– Southbound– Eastbound– Westbound

• North and South bound are green at the same time• East and West bound are green at the same time• May need to add left-hand turn lanes later as traffic

increases at this intersection

87

Traffic Lights: Version 1

• Successfully directs traffic flow• What are the drawbacks?

– Cannot stop in the middle of a cycle– Not easy to modify for future traffic needs– Difficult to determine what function each Boolean performs

88

Traffic Lights: Version 2

• Improvements:• Uses a Case Structure vs. a Sequence Structure

– Allows the Traffic Engineer to break into the cycle– Can also add cases for future modifications

89

Traffic Lights: Version 3

• Improvements:• Additional Documentation added to Describe Code

Functions and Wire Data• Group front Panel Objects into Clusters

– Makes all indicators easily available in all cases– Adds inherent documentation– Note with updating the indicators outside the case, the timing must

also reside outside the case

90

Traffic Lights: Version 4

• Improvements:• Use of a Type Defined Enumerated Control for determining

the next state– Type Definition allows for scalability of the design. New states can be

added to the control and all constants made from that control are updated

91

Traffic Lights: Version 5

• Improvements:• Incorporate a timing method that allows for immediate

control of the execution– For most applications, immediate control is needed to allow the system

to respond to critical inputs– Note the addition of the time delay in the loop. This prevents

LabVIEW from taking 100% CPU time for it’s execution

92

Traffic Lights: Version 6

• Adding Indicators for Left Turn Signals:• With the indicators in clusters, adding indicators is

straightforward– Add the indicators on the front panel by copying the existing indicators– On the Block Diagram, create constants for each indicator– Add the constants to the cluster constant on the left-side of the Block

Diagram– All indicators are now available in every state

93

Traffic Lights: Version 7

• Adding Turn Lane sensors:• Add the Booleans and copy the Enum constants to direct

the program flow– The sensors are checked when the yellow light is illuminated for the

opposite direction• This is a complete, working version of the application

– It is completely dataflow driven, no variables were needed

– It is easily scalable

– It is documented

94

Traffic Lights: Version 8

• This version is similar to version 7, however it incorporates a case structure rather than discrete Selectors

• It is also a completely acceptable solution

95

Traffic Lights: Version 9

• Again, this is similar to version 7, only this implementation uses Queues to select the next state

96

Additional Notes on Programming Style

• What Style issues would cost points in this Block Diagram?

97

Additional Notes on Programming Style

• What is the source for this Error Cluster?

• Left to right flow is important for readability

98

Additional Notes on Programming Style

• Watch for unnecessary bends in wires

99

Additional Notes on Programming Style

• Wire into and out of tunnels

100

Additional Notes on Programming Style

• Wire to obvious terminals on objects

101

Additional Notes on Programming Style

• Do not wire underneath objects

102

Additional Notes on Programming Style

• Do not cover objects with other objects

103

Additional Notes on Programming Style

• Wire into and out of the correct terminal locations

104

Additional Notes on Programming Style

• Always place a time delay in loops

?

105

Additional Notes on Programming Style

• Adjust the size of structures to show objects in all cases

106

Question / Answer Session on Certification

• Technical Questions• Exam Administration Questions

• Best wishes on your Certification Exam

David Bonal

Mike Fillian

107

Thank you!