Language - LabVIEW: Difference between revisions

From Phidgets Support
No edit summary
 
(31 intermediate revisions by 4 users not shown)
Line 1: Line 1:
[[Category:Language]]
[[Category:Language]]
{{OSLang|[[File:icon-LabVIEW.png|64x64px|link=|alt=]]|LabVIEW, developed by [http://www.ni.com National Instruments] is dataflow programming language for data processing.}}
__TOC__


==Introduction==
We provide support for LabVIEW on the '''Windows''' operating system. By using LabVIEW, you will have access to the complete {{Phidget22API}}, including events. We also provide example code in LabVIEW for all Phidget devices.


{{LanguageSupport|LabVIEW|the complete Phidget API, including events|all Phidget devices.| Windows. A minimum version of LabVIEW 2009 is required. OS X and Linux are unsupported as the Labview/Phidgets combination has not been tested on those systems.|}}
LabVIEW is a development environment for a graphical programming language created by National Instruments.  


Note that with LabVIEW you can install a 32-bit version on a 64-bit computer without any issues, but the 64-bit version cannot obviously be installed on a 32-bit computer.  The reason this is relevant is that the respective versions cannot create executables that the other can run.  I.E. 64-bit LabVIEW cannot generate a 32-bit executable.  The upshot of this is that if you need your executable to be compatible with older machines (such as Windows XP machines) then you will need to use a 32-bit version of LabVIEW to create your program.
==Setup Guide==
 
<div class="phd-deck-sequence">
==Quick Downloads==
__NOTOC__
{{QuickDownloads|LabVIEW|
{{PT3_LABVIEW_WIN}}
{{APIQuickDownloads|{{SERVER}}/documentation/LabVIEW_Manual.pdf PDF}}
</div>
{{ExtraAPIQuickDownloads|{{SERVER}}/documentation/web/LabVIEWDoc/index.html|HTML version of}}|
{{ExampleQuickDownloads|{{SERVER}}/downloads/examples/LabVIEWx86.zip| (32 bit Windows - same file as LabVIEW library)}}
{{ExampleQuickDownloads|{{SERVER}}/downloads/examples/LabVIEWx64.zip| (64 bit Windows - same file as LabVIEW library)}}|
{{ExtraLibraryQuickDownloads|{{SERVER}}/downloads/examples/LabVIEWx86.zip|LabVIEW|(32 bit Windows - same file as LabVIEW Examples)}}
{{ExtraLibraryQuickDownloads|{{SERVER}}/downloads/examples/LabVIEWx64.zip|LabVIEW|(64 bit Windows - same file as LabVIEW Examples)}}
{{WindowsQuickDownloads}}
}}
 
Please note that the x64 examples are only compatible with LabVIEW 9 and newer.
 
==Getting started with LabVIEW==
 
If you are new to writing code for Phidgets, we recommend starting by running, then modifying existing examples. This will allow you to:
{{ExampleCodeReasons}}
 
==Windows (XP/Vista/7/8)==
 
===Description of Library Files===
LabVIEW programs on Windows depend on the following two items, The installers in the [[#Libraries and Drivers|Quick Downloads]] section put only the {{Code|phidget21.dll}} into your system. You will need to manually put the Phidget LabVIEW library onto your system:
* <b>{{Code|phidget21.dll}}</b> contains the actual Phidget library, which is used at run-time.  By default, it is placed in {{Code|C:\Windows\System32}}.
* <b>{{Code|Phidgets LabVIEW library}}</b> contains the Phidget library for LabVIEW. You need to place the library into your LabVIEW functions palette. Instructions are explained in the [[#Write Your Own Code | Write Your Own Code]] section.
 
If you do not want to use our installer, you can download the [{{SERVER}}/downloads/libraries/phidget21-x86.zip {{Code|phidget21.dll}}] and manually install it where you want; refer to our [[OS_-_Windows#Manual_File_Installation | Manual Installation Instructions]].
 
We include instructions for LabVIEW 2011 on [[#Use Our Examples | using our examples]] and [[#Write Your Own Code | writing your own code]].
 
====Use Our Examples====
 
To run the examples, you first download the examples found in the [[#Example Code | Quick Downloads]] section and unpack them into a folder. Here, you will find the {{Code|examples}} folder, which contains {{Code|vi}} programs for all the devices. Each {{Code|vi}} example demonstrate the usage of a few of the device's properties. To get a broader understanding of the device, you should take a look at all the  {{Code|vi}} examples inside the directory for your device. {{FindYourDevice}}
 
1. Inside the {{Code|examples}} folder, navigate to the directory for your device.
 
2. Open up any {{Code|.vi}} of your choice in LabVIEW. In this section, the {{Code|Sensor to Output Example.vi}} of the PhidgetInterfaceKit examples will be used.
 
[[File:LabVIEW Win Front Panel.PNG|link=|alt=Front Panel]]
 
You will see the front panel of the example. The front panel shows the user interface of the {{code|vi}} program.
 
3. Next, let us take a look at the block diagram by navigating to {{Code|Window &rarr; Show Block  Diagram}}.
 
[[File:LabVIEW Win Block Diagram 1.PNG|link=|alt=Block Diagram]]
 
The block diagram shows the logic of the application.
 
[[File:LabVIEW Win Block Diagram 2.PNG|link=|alt=Block Diagram]]
 
4. The only thing left to do is to run the examples! Navigate to {{Code|Operate &rarr; Run}}.
 
[[File:LabVIEW Win Run 1.PNG|link=|alt=Run]]
 
5. The application will run.
 
[[File:LabVIEW Win Run 2.PNG|link=|alt=Run]]
 
You can determine that your device is connected to your application if you see the indicator for {{Code|attached}} turn green and the correct serial number is displayed. These features are available in most of the example {{Code|vis}} we provide.
6. When you are ready to terminate the application, click on the [[File:LabVIEW Win Stop.PNG|link=|alt=Stop]] button to release the hold on the device. Please keep in mind that the application may not terminate properly if you stop it by clicking on {{Code|Operate &rarr; Stop}}.
 
Once you have the LabVIEW examples running, we have a [[#Follow the Examples|teaching]] section below to help you follow them.
 
====Write Your Own Code====
 
When you are building a project from scratch, or adding Phidget function calls to an existing project, you'll need to add the Phidget LabVIEW library to your development environment. To begin:
 
1. Navigate to {{Code|Tools &rarr; Advanced &rarr; Edit Palette Set}} to modify the functions palette.
 
[[File:LabVIEW Win Functions Palette 1.PNG|link=|alt=Edit Function Palette]]
 
2. The functions palette will show up. Right click an empty area, and select {{Code|Insert &rarr; Subpalette}}.
 
[[File:LabVIEW Win Functions Palette 2.PNG|link=|alt=Insert Function Palette]]
 
3. Next, select {{Code|Link to a directory}}.
 
[[File:LabVIEW Win Functions Palette 3.PNG|link=|alt=Link to a library]]
 
4. Make sure you have the Phidget LabVIEW library and examples in the [[#Libraries and Drivers| Quick Downloads]] section downloaded and extracted. After extracting, you will find the {{Code|Phidgets}} folder. In LabVIEW, browse to the {{Code|Phidgets}} folder, and select {{Code|Current Folder}}.
 
[[File:LabVIEW Win Functions Palette 4.PNG|link=|alt=Select Phidgets library]]
 
This will load the Phidget LabVIEW library into the functions palette. You can find all the functions that pertain to Phidgets inside the {{Code|Phidgets}} palette.
 
[[File:LabVIEW Win Functions Palette 5.PNG|link=|alt=Phidgets LabVIEW Library]]
 
5. Click on {{Code|Save Changes}} in the {{Code|Edit Controls and Functions Palette Set}} window.
 
[[File:LabVIEW Win Functions Palette 6.PNG|link=|alt=Save Function Palette]]
 
The project now has access to the Phidget function calls and you are ready to begin coding.
 
The same [[#Follow the Examples|teaching]] section which describes the examples also has further resources for programming your Phidget.
 
==Follow the Examples==
 
By following the instructions for your operating system and compiler above, you probably now have a working example and want to understand it better so you can change it to do what you want. 
 
Since LabVIEW is a graphical language, the best way to get the 'code snippets' you need is to take them from our examples.  The best way to find what blocks exist and how to use them is probably to switch between the block diagram view and the GUI view between examples that apply to you.  This will allow you to use pieces from our examples to create your own LabVIEW application.
 
Your main reference for writing LabVIEW code will be our LabVIEW API information, with syntax for all of our functions:
 
{{UsingAPhidgetInCodeGeneral|both of which are available in LabVIEW|[{{SERVER}}/documentation/LabVIEW_Manual.pdf API Manual]}}
 
If you are really getting in to using Phidgets, you probably want our more general programming resources as well.  Although these are focused on the text-based languages that we support (C++, Java, etc), the concepts remain the same on how Phidgets are used within code.  Our [[General Phidget Programming]] page gives more information about:
* [[General Phidget Programming#Using Multiple Phidgets|Using Multiple Phidgets]] (or a Phidget [[General Phidget Programming#Creating a Software Object|other than the Interface Kit]])
* Catching [[General Phidget Programming#Exceptions and Errors|exceptions and errors]] and [[General Phidget Programming#Logging|using logging]]
* [[General Phidget Programming#Event Driven Code|Event catching]] versus [[General Phidget Programming#Logic Code|direct polling]]
* And more....
Of course, most of these concepts are covered using block flow within LabVIEW, but knowing the general order of operations can help you structure your code.
 
==LabVIEW Error Codes==
LabVIEW uses a number of Phidget specific error codes which are not always well described when they pop up.  If you are debugging your application and are running into one that you cannot figure out you can get more information from the [[General Phidget Programming#Error Codes|Phidget Error Codes list]] under "Software Errors".  The LabVIEW error codes are just the Phidget error codes + 7000.
 
==Common Problems and Solutions/Workarounds==
 
===Issue: Events can occasionally cause issues, especially when there are multiple of the same type of event===
In other words, if you open 2 Interface Kits and have a sensor change event for each one your system can behave unpredictably.  This problem is a quirk in the way that LabVIEW handles passing pointers to C.  There are a few solutions to this issue, either:
 
*Stop using events and simply poll the device.  Events work similarly to polling in LabVIEW anyway and should not cause substantial performance changes to your application.
*Implement a simple fix to the events which are causing the problem.  The pointer is identical in the case where two events of the same type are passed from a single function.  This causes the events in C to output to the same event in LabVIEW.  To get around this you would need to copy the offending subVI, then change the name of the cluster object in it from "Event" to something else (your choice), change the name of the .vi to something else and then use those two different subVIs in your program.  You would need to repeat this for each subsequent event of the same type you wish to have.
 
Either solution will work and while the first is a bit cleaner the second will work just as well.
 
===Issue: I cannot attach to an object any more after running my program once===
What this means is you probably halted the VI instead of using the stop button.  Halting operation will not release the Phidget device properly and will consequently make it unusable until LabVIEW has been exited and restarted.  In order to prevent this from happening you should always use the stop button instead of simply halting operation.  That way the close subVI gets called and the Phidget will be released.

Latest revision as of 21:42, 10 August 2023


We provide support for LabVIEW on the Windows operating system. By using LabVIEW, you will have access to the complete Phidget22 API, including events. We also provide example code in LabVIEW for all Phidget devices.

LabVIEW is a development environment for a graphical programming language created by National Instruments.

Setup Guide

Language - LabVIEW

Windows with LabVIEW

Welcome to using Phidgets with LabVIEW! By using LabVIEW, you will have access to the complete Phidget22 API, including events. We also provide example code in LabVIEW for all Phidget devices.

LabVIEW is a development environment for a graphical programming language created by National Instruments.

Requirements

First, make sure you have the following:

● Phidgets Drivers for Windows installed(see Part 1 of this user guide)

Phidget LabVIEW Library downloaded


Note: The LabVIEW Library also contains example VI trees, which we'll cover later in this guide.

Using Our Examples

One of the best ways to start programming with Phidgets is to use our example code as a guide.

Unpack the Phidget LabVIEW Library and rename the unpacked folder to Phidgets.

Using Our Examples

Navigate to the following directory:

● For 32-bit LabVIEW, C:/Program Files (x86)/National Instruments/LabVIEW 20xx/instr.lib

● For 64-bit LabVIEW, C:/Program Files/National Instruments/LabVIEW 20xx/instr.lib

Place the renamed folder at this location:

Using Our Examples

Next, open LabVIEW and create a new VI:

Using Our Examples

In the new block diagram window, open the functions palette (View -> Functions Palette).

Next, go to the Phidgets palette (Instrument I/O -> Instrument Drivers -> Phidgets):

Using Our Examples

Next, select a palette that will work for your Phidget and drag VI Tree.vi onto your block diagram:

Using Our Examples

Right-click on VI Tree.vi and select Open Front Panel:

Using Our Examples

From the front panel, navigate to the block diagram (Window -> Block Diagram):

Using Our Examples

The VI Tree Block Diagram lists all VIs available for its Phidget Class, and which subpalette to find them under. The examples are located near the bottom of the block diagram. Right-click the example you would like to use and select Open Front Panel:

Using Our Examples

When you are ready, press Run and the application will demonstrate the Phidget's functionality.

Here is an example of an Accelerometer channel on a Spatial Phidget:

You should now have the example up and running for your device. Play around with the device and experiment with some of the functionality. When you are ready, the next step is configuring your environment and writing your own code!

Configure Your Environment

First, we recommend enabling the Show constant labels setting in LabVIEW. This setting will reduce complexity when developing, and is especially recommended for beginners.

To enable the setting, first navigate to Tools -> Options on your block diagram:

Configure Your Environment

Select the Environment category and enable Show created constant labels at the bottom:

Configure Your Environment

To begin working with Phidgets, you will need both a StartPhidget VI and a ClosePhidget VI:

Configure Your Environment

Select a class that will work with your Phidget from the drop-down menu for each VI:

Configure Your Environment

You can now add device information or any initialization parameters to the StartPhidget VI. Using your mouse, hover over each of the connection nodes to see information about it:

Configure Your Environment

If you would like to add device information or initialization parameters, right-click the connection node and navigate to one of the following:

Create -> Constant

Create -> Control

Configure Your Environment

Creating a constant will allow you to modify device information from the block diagram:

Configure Your Environment

Creating a control will allow you to modify device information from the front panel:

The environment now has access to Phidgets. Next, we'll walk through writing your own code.

Write Code

Along with this guide, your main resources for writing LabVIEW code will be:

● The examples

● The Phidget22 API

● The VI help files

Examples of more complex general topics such as using multiple Phidgets and connecting to a Phidget over the Network Server can be found under the VI Tree for the Phidget Common palette.

Example Flow

Most LabVIEW examples follow the same basic flow: starting a Phidget, reading some data, and closing the Phidget.

Step One: Initialize, Open And Wait For Attachment Of The Phidget

The entire process of opening and initializing a Phidget can be done by using the version of StartPhidget.vi that corresponds to your device. In most cases, StartPhidget.vi will also attempt to wait for the first data to become available from the device for 5 seconds after initialization.

If you'd prefer to initialize the device manually, you can use OpenPhidget.vi for your device and call the individual functions to set up the device.

Step Two: Do Things With The Phidget

You can read data and interact with your Phidget both by polling it for its current state (or to set a state), or by catching events that trigger when the data changes.

To poll devices, simply place the corresponding blocks:

To use events, there are three main blocks for each type, to create, execute, and close the event handler. When creating the event, all devices using an event of the same type must be grouped into an array to ensure the events get processed correctly.

Step Two: Do Things With The Phidget

Once created, the events will be processed by [Name]EventExe.vi. When an event occurs, the pertinent information will be output, as well as information to reference which device caused it.

After a program has run its course, the event handler must be closed.

Step Three: Close And Delete

Closing a Phidget is done by using the appropriate version of ClosePhidget.vi

That's all the basic building blocks you need to create a LabVIEW program using Phidgets.

Help and Documentation

For more information on the use of any VI and its parameters, right-click the VI and select Help

Help and Documentation

This will take you to an HTML page outlining the function of the VI. This includes a list of all its parameters, which devices support them, their range of acceptable values, and their default values, where applicable:

What's Next?

Now that you've set up Phidgets in your programming environment, you should read our guide on Phidget Programming Basics to learn the fundamentals of programming with Phidgets.

Continue reading below for advanced information and troubleshooting for your device.

Scroll down for device-specific troubleshooting, or go to the next slide for LabVIEW troubleshooting.

LabVIEW Troubleshooting

Expand All
I cannot attach to an object any more after running my program once

What this means is you probably aborted the VI which stopped the program before the Phidget could be closed. Aborting execution will not release the Phidget device properly and will consequently make it unusable until the Phidgets library (or LabVIEW) has been restarted.

To resolve this, you may open a new VI, place PhidgetResetLibrary.vi, and run it. This will completely reset the current Phidget library, making it possible again to connect to all Phidgets.

Note that this action will close all Phidgets that are currently open in LabVIEW, and should not be used while other Phidgets-related LabVIEW VIs are running.

Phidget Reset All Palette.png

Phidget Reset All.png

In order to prevent this from happening you should use a software stop button when possible instead of halting operation. That way the Close subVI gets called and the Phidget will be released.

I cannot find my error code on this website

All Phidgets-based error codes in LabVIEW are offset by 7000 to avoid conflicting with LabVIEW's own error codes. To get the equivalent Phidget return code from the LabVIEW error code, simply subtract 7000. For instance, error code 7003 in LabVIEW translates to Phidget Return Code 3.

To find the meaning of all Phidget Return Codes, you can go to the Phidget22 API page, and open the PhidgetReturnCode section under Enumerations.

Events Can Occasionally Cause Issues, Especially When There Are Multiple Of The Same Type Of Event

In other words, if you open 2 of the same device and have a sensor change event for each one your system can behave unpredictably. This problem is a quirk in the way that LabVIEW handles passing events to and from C. There are a few solutions to this issue, either:

  • Stop using events and simply poll the device. Events work similarly to polling in LabVIEW anyway and should not cause substantial performance changes to your application.
  • Implement a simple fix to the events which are causing the problem. The pointer is identical in the case where two events of the same type are passed from a single function. This causes the events in C to output to the same event in LabVIEW. To get around this you need to copy the offending subVI, then change the name of the cluster object in it from "Event" to something else (your choice), change the name of the .vi to something else and then use those two different subVIs in your program. You would need to repeat this for each subsequent event of the same type you wish to have.
  • Make an array of all the devices you intend to use with the event, and feed the array into a single EventCreate vi, and use a single EventExe handler for all the events. When using this method, it might be tempting to add multiple event handlers, but keep in mind that events only occur once, in whichever handler sees them first. When running multiple Phidgets through the single event handler, you can determine which one caused the event by comparing the phid terminal from the EventExe VI to the Phidget IDs (Device In/Device Out) of your Phidgets.

We recommend using either of the the first two solutions where possible. The first is a bit cleaner, but the second will work just as well. We only recommend using the third method in cases where it is not practical to manually create individual event handlers.

«
»