Eyes on VIs

LVSpeak: Automating VI development through speech

2009-07-03T14:05:00.014-05:00

Eyes on VIs is pleased to welcome its first guest blogger, Norm "The Captain" Kirchner! Norm is the first person in history to sacrifice his LabVIEW Champion status for the pleasure of working at National Instruments. (NI Employees cannot be LabVIEW Champions). Norm has been using LabVIEW for over 9 years and he is going to share his "LVSpeak" project, which (I hope you will agree) is pretty darn amazing. Thanks for joining us, Norm!

- Christina

Imagine if LabVIEW was able to read your thoughts and react to them. You just think “edit icon” and *pop* the icon editor is opened for you immediately. Imagine if every time you wanted to drop a property node for a control or group of controls, they just showed up on the diagram.

Although this ability is not implemented in LabVIEW yet, we can get darn close by using our voice and a little creative coding.

LVSpeak (LabVIEW Speak) is a very simple concept with a great deal of possibilities. It utilizes the Microsoft Speech API (SAPI) and provides an open and extendable interface to it within LabVIEW. Currently, two extensions of that architecture exist. They are ‘Quick Edit’ and ‘Speech Enabled Quick Drop’.

These extensions of LVSpeak and the LabVIEW development environment give the coder tools to greatly speed the process of code creation and modification upwards of 70%.

Note: Volume on the videos is very low, turn speakers all the way up

Video 1: Code creation

WHY

LabVIEW is an easy to use and intuitive application development environment and programming language, but there are still some basic actions that require multiple clicks and force the user to navigate through a variety menus and options.

LVSpeak was developed to take those minor but time consuming steps and reduce them to a single voice command. At the root of this entire effort is one simple premise, “A good engineer is a lazy engineer”. And until we can program LabVIEW with our minds, turning a 4 step, 3 second action into a ½ second, 1 step voice command, makes me a happy lazy engineer.

At the end of the day, any action that requires you to remove your hand from the mouse (Ctl+I), or needs more than two mouse clicks and navigation deeper than a top level context menu (Label Visible) is warranted to become a Voice Command

HISTORY

When LabVIEW Scripting was still very new in LabVIEW 7.0 and some of it’s functionality was accidentally exposed by NI, it occurred to me that you could combine this scripting ability to use LabVIEW code to write LabVIEW code along with the free Microsoft speech recognition technology and do some creative things. Although an interesting idea, integrating dll’s and ActiveX objects into G was still foreign to me and presented a barrier that caused LVSpeak to sit dormant until NI Week 2008 and the release of Quick Drop.

Almost immediately I recognized a synergy between this great new development tool in LabVIEW and the still undeveloped LVSpeak. This was only confirmed further when I was watching the coding challenge at NI Week 08. During the coding speed challenge, the creator of Quick Drop, Darren Nattinger, was slowed to a crawl when doing simple tasks like creating a constant or typing verbose function names in the Quick Drop window.

At that point I realized that all the components needed, to allow the developer to program as fast as they could imagine the code, were in place.

HOW

The how is actually more simple than I would like to admit.

There are two key components to the Microsoft SAPI that are utilized in LVSpeak

Grammar List
'Speech Recognized’ .NET Callback Event

Within LabVIEW, two components are required to enable speech recognition in any program.

Load Command List (Grammar)
Register for speech recognized event

The way everything plays together is quite simple

LVSpeak Core starts and

Initializes the Microsoft SAPI
Creates a LV User event
Registers a callback VI to be run when speech is detected and fire the LV User Event with the command

Programs utilizing LVSpeak

Register for the Grammar Detected event
Load their command list into the “Grammar”
Catch the fired event and respond accordingly to the string

For speech enabled Quick Drop, the grammar list is everything in the function palette, and whenever the LVSpeak event is caught, it takes the detected string and loads it into the text box as if you had just typed it.

Quick Edit follows that same flow. The grammar list is all created Quick Edit commands pulled from an enumeration. When one of those commands is detected, it runs the corresponding code to execute that command.

Video 2: Basic detection

Video 3: Quick Edit Demo

Getting Started

To start developing LabVIEW with your voice you need to download and install

VI Package Manager (JKISoft.com)
Microsoft Speech SDK 5.1 (http://tinyurl.com/lzz3t5)
LVSpeak Core
LVS Quick Drop Addon

Once all these parts are installed, you should see a new item in your LabVIEW tools menu "Enable LVSpeak"

Select that option, and you should see two floating windows show up.
If you microphone is active, manually drop some controls on your front panel, flip over to the block diagram, select all the controls and say "Label Side" in a relatively monotonic voice.

Summary

If you program LabVIEW on a regular basis, begin paying attention to how long some tasks take and how often you repeat some basic tasks that could be streamlined by a little scripting automation.

Controlling LV with your voice is not just a novel idea.
It is truly a quantum leap forward in how you develop your code and a HUGE performance booster.

So wipe the dust off of your microphone or headset and get ready to take your development process to the next level.

~,~
The Captain Was Here

Norm Kirchner

PS Thank you Christina for your patience with me getting this out to you and providing a great resource for the rest of us LabVIEW nuts out in the world.

VI Makeover Edition - Customizing a Slider

2009-06-28T13:19:00.003-05:00

In a previous post, I talked about a VI for an NI Week keynote demo.

Now I'd like to talk about customizing the slider control for that project.

You can watch the video on EyesOnVIs.com or YouTube, or you can read the text version below.

When customizing a control, I like to start with the simplest control of the right type, which usually means controls from the Classic palette. For this demo, I customized a Classic Vertical Pointer Slide. Note that the control editor lets you change the appearance of a control, but not its functionality.

You can edit a control either from the Edit>>Customize Control menu or from the Advanced>>Customize right-click menu.

This will open the control in the Control Editor. From there, you can customize using the normal right-click options (such as setting the Scale style as I did for this demo) or go into "Customize" mode either by clicking the toolbar button to switch to the tweezer icon or by showing the Parts window from the Window menu.

You can find the slider thumb by cycling through the Parts and then right-click on it to see the options for changing its image. For this demo, I used a graphic that I created myself in a graphics program, but there are lots of sources for nice, professional images that you could use for your projects. You can find the graphics I made in the Image Archive on my website, EyesOnVIs.com.

After customizing the thumb, I added some free labels for + and - scale markers, made the text big and bold so it would be easily visible on the keynote projector screens, and colored the increment and decrement arrows transparent.

I hope this inspires you to make your own custom controls and take your LabVIEW UIs to the next level!

LabVIEW Scripting

2009-05-29T17:56:00.002-05:00

If "VIs dynamically constructing new VIs" doesn't sound like the premise of a bad summer movie to you, then you might be interested in the recent LabVIEW Scripting post on NI Communities.

To quote Darren Nattinger (who has a lot more experience with Scripting than me), "LabVIEW Scripting is an (until today) internal LabVIEW feature that allows you to write VIs that create, modify, and inspect other VIs."

Important note: "As this is an 'NI Labs' product, NI will not be supporting LabVIEW Scripting through Applications Engineering." That means if you have technical questions, you will need to post them to the API Community instead of going through NI's usual support channels.

In my experience, Scripting is very difficult to work with, but I am really looking forward to seeing what people will do with it. JKI has already announced the JKI Right-click Framework for LabVIEW, which will allow end-users to add features to the LabVIEW editor itself. Pretty cool.

Help Define the New LabVIEW Advanced Course

2009-05-07T21:36:00.003-05:00

Scott Romine and Nancy Hollenback are rewriting the LV Advanced I Course, and they want your help!

Join the Designing, Drafting, & Developing the LV Advanced Course group on NI Communities to participate in discussions and polls that will shape the future of the course.

I've joined the group, and I look forward to hearing everyone's input on what techniques every LabVIEW developer should master!

Tree Control Scrollbar Tip

2009-04-03T20:16:00.009-05:00

One of my colleagues recently showed me a VI that automatically shows and hides the scrollbars of the tree control, as well as resizing the columns, depending on the text in the cells. Those of you who are familiar with the tree control are probably aware that it doesn't have this capability built-in.

The VI isn't in the palettes but is in the tree folder of vi.lib. It's called Tree_ShowScrollBar.vi.

To see a brief demo of the functionality, check out this video on my website. If you have trouble viewing that video, you can try the YouTube version.

"Large LabVIEW Application Development" and "UI Interest" Groups

2009-04-02T20:40:00.010-05:00

One of my colleagues, Elijah Kerry, has a group on NI Communities dedicated to "Large LabVIEW Application Development." His recent blog post on "Professional User Interfaces in LabVIEW" has links to numerous examples of "the level of customization and flexibility that LabVIEW controls and indicators provide." Please check it out!

Also, be sure not to miss the UI Interest Group, which has cool info and examples, including the "ni.com Inspired Custom Control Suite" (which Jim Kring has kindly created a VI Package for, so you can easily install it with the VI Package Manager).

Finally, I'd like to send out a personal thank you to Christopher Relf for the kind comments about my article in the latest Instrumentation Newsletter, entitled Your VIs: Good, Bad, or Ugly? The article is available online for anyone who missed it in the mail!

There Are No Strict Type Definition Constants

2009-03-25T20:43:00.008-05:00

Type definitions (aka typedefs) are very useful. However, they also have some unexpected behaviors that can cause you a lot of trouble.

As a usability advocate, it pains me every time I have to explain this one, but here it is: There are no strict typedef constants in LabVIEW.

I am not going to try to defend this as "good" behavior. But it's not a bug when constants linked to strict typedef files only update on type changes.

Basics of Custom Controls

LabVIEW has three kinds of custom controls (.ctl files).

Unlinked custom control. A "regular" custom control uses a definition (.ctl) file but the instances are not linked to the definition file. Thus, when you edit the .ctl file, instances that were created from it in the past do not update.
Linked by type (aka typedef or type definition). Whenever the definition (.ctl file) changes type, all instances need to update. If the instance is set to auto-updating, it will update itself on load. [Note, however, that it will not auto-update while the definition file is open in the control editor.] If not set to auto-updating, you must right click on each instance to update it.
Linked by all attributes (aka strict typedef). Similar to a typedef, except that any time the definition changes, all instances must update. This is achieved by time stamp comparison between the definition and instances. The intent is to have all instances cosmetically identical to the definition. Since most cosmetic attributes are invalid on the block diagram, there is no such thing as a strict typedef constant. Constants linked to strict typedef definitions act like typedef constants.

Confusion Over When Typedefs Update

If you have a ring, its type is its numeric representation, e.g. unsigned word.

If you have an enum (which can look identical on the front panel), its type contains its item names.

Thus, when you add items to a typedef ring definition file, the instances don't update (because the type didn't change). When you add items to a typedef enum definition file, the instances do update. However, if you make a strict typedef ring, then control instances will update when you add items. But since there's no strict typedefs on the diagram, constants that are linked to a strict typedef ring will not update when you add items. This behavior is confusing, but it is working as designed.

Forcing Updates

Even though typedefs only update when types change, instances get cosmetic changes from the definition whenever they update. So one trick to "push" changes to typedef instances is to change the data type, apply changes, and then change the data type back. [edit, March 26 - Note that the typedef instances need to be in memory when you use this trick].

Unreliability of Data

Another potential problem with typedefs is that you shouldn't rely on them keeping their data values when they update. LabVIEW will attempt to preserve data. For example, if you have a typedef numeric constant and change its representation, LabVIEW will convert the value. However, there are many cases where LabVIEW will not preserve the values correctly, especially with clusters, so it's a good policy not to rely on the values being preserved. (Or to visit all the typedef instances when you make changes, in order to verify their values).

Why Use Typedefs?

I would be remiss if I didn't make a case for using typedefs despite the potential problems that I've covered here. Typedefs let you change the type of all the instances with a single edit. This is very useful, for example, when you have a set of VIs operating on a cluster and you later realize you need to add or remove items to it. Without using a typedef, you have a lot of broken wires until you visit every VI that passes the cluster in or out of its connector pane. And strict typedefs are extremely valuable for maintaining consistent user interfaces - you can make controls on any number of VIs have the same appearance.

One final note - if you're using LabVIEW 8.2 or later, and you want to use a typedef so that you can encapsulate data for passing between VIs, then you should consider using a LVClass instead. You may still choose to use a typedef, but it's good to evaluate, because LVClasses serve the role well and give you a lot of other benefits as well.

[Please ignore this edit. I'm trying to see if updating an older post makes it show up on my blog mirror on NI Communities, without causing ill effects.]

VI Makeover Edition - Part 1

2009-03-03T19:48:00.006-06:00

For a long time, I've been meaning to do a series of posts I call the "VI Makeover Edition" where we take a VI front panel from "drab" to "fab!" :-)

I helped "spiffy up" a VI for an NI Week keynote demo last year. It is a graphic equalizer powered by LabVIEW MathScript. You can watch the demo video on ni.com.

The goal was simply to make the VI look better on the big screen, and make it easier to see the operation of the controls from the back of the room.

The original VI looked something like this:

And the final VI looked something like this:

Some of the tips and tricks I plan to cover include:

VI panel wallpaper
Background images and locking
Customizing the parts of a slider control
Adding decorations to controls
Using transparent color
Gradients and graphics
Grouping and alignment

If you want me to cover these in a particular order or have questions in advance that I should cover, please let me know!

You're Invited - LabVIEW Beta Program

2009-02-09T16:46:00.002-06:00

I am pleased to announce that NI is calling for participation in the LabVIEW 2009 Beta program!

Here is more information from the Beta program coordinators:

You are invited to register for participation in the LabVIEW 2009 Platform beta program.

You can register by visiting http://www.ni.com/beta and selecting "LabVIEW 2009 Platform" from the list of beta programs. Please complete the profile questions that will help us understand your experience and use cases with LabVIEW. Make sure you agree to the T&C of the beta program so that you can be approved.

After you register, please be patient for the beta coordinators to process your application. You will be notified when you have been approved. Registration does not necessarily guarantee you a position in the beta program. Determination of acceptance into the program is up to the sole discretion of National Instruments.

We will have a private section of the Discussion Forums on NI Developer's Exchange set up for beta users to discuss the beta version of the LabVIEW 2009 Platform.

We eagerly await your registration. Thank you for your invaluable help in assisting us design and test LabVIEW.

Tip for iPhone Users

2009-02-08T10:38:00.002-06:00

This past week I learned that I can create links to web pages on my iPhone home screen. I love having quick access to my favorite web sites! Here's the description from Apple.com:

When you find a web app you like, you can put it front and center on your Home screen. Just open the web app on your iPhone or iPod touch, tap the plus sign, and then tap “Add to Home screen.” A Web Clip will be added to your Home screen automatically for easy, one-tap access.

If you add a web clip to Eyes on VIs, you'll get to see the custom icon I made for it!

Captions

2009-01-28T20:44:00.008-06:00

Last week I was fixing a problem with a VI where the wrong text was shown in the Context Help window for some of the controls. Perhaps it's a VI you recognize...

Yes, embarrassingly enough, it was a bug with my Getting Started window. The small images to the left of some of the links are picture rings. They were showing their decidedly unhelpful labels in the help window:
After deciding that the picture rings should simply have the same names and descriptions as the items to their right, I added a property node to set the caption text and description.

Then I ran the VI. It didn't work. In fact, it fixed the context help for some, but not all, of the picture rings.

You might already be able to spot what I did wrong. If not, maybe you'll be able to guess after I explain more about captions.

What Are Captions?

When you place a control on a VI's front panel, it has a label where you give it a name. This name is shown in the context help window. It also provides the identifier for programmatic interfaces such as Set Control Value.

When the LabVIEW team added features to support localization of VIs, we needed to be able to change the name of a control. But if we changed the label, calls to interfaces like Set Control Value would break. So we introduced another kind of label, called a caption.

We also didn't want to make VIs bigger (in memory and on disk) by adding a part to every control and indicator that most wouldn't use, so captions are "lazily created." When you right-click on a control and select Visible Items>Caption, LabVIEW creates a caption for the control. It also hides the label (since you usually use a caption instead of a label, not in addition to it) which leads to the confusing situation where the menu option appears to have no effect (because the caption initially looks exactly like the label and is in the same location).

You can tell that a control has a caption by looking at the context help window. When the VI is in edit mode, the context help displays the caption and the label, with the label in square brackets. (Note that when the VI is running, the context help displays the caption but not the label).

Fixing the Bug

Coming back to my original story, when I checked the error out of the property node that was setting the ring caption, I found it was generating error 1320: "In run mode, LabVIEW cannot get or set a property for a control part that has not been created."

The problem was that some, but not all, of the rings had caption parts. As I mentioned earlier, captions are lazily created - you can't set the text on them if they don't exist, and LabVIEW can't create them on running VIs. The solution was to show (and thus create) the captions for all the rings. Luckily, I was using LabVIEW 8.6 and could use the new multi-select feature. I selected all the rings, right-clicked to show the Properties dialog and showed all their captions in one step. Problem solved.

Learning LabVIEW

2009-01-08T08:36:00.004-06:00

A LabVIEW user who is aspiring to become a CLAD (Certified LabVIEW Associate Developer) asked me for book recommendations. I didn't know the answer, but I knew who to ask. My colleague Nitin Thomas, one of our LabVIEW Product Support Engineers, helped me out with the following links, which I think would be helpful to anyone trying to learn LabVIEW:

How Can I Learn LabVIEW on NI's Academic site. This page is a great compilation of resources, including courses, webcasts, books and more.
LAVA Wiki book list
Dr. Scott Hannah's extensive LabVIEW book list.
"How Can I Prepare for the Certified LabVIEW Associate Developer (CLAD) Exam?" on ni.com, including preparation guide and webcast.

New Blog from Darren of LabVIEW R&D

2009-01-05T15:30:00.000-06:00

I'm thrilled that Darren Nattinger (of Darren's Weekly Nugget fame), creator of the Quick Drop feature of LabVIEW, has started his own blog: LabVIEW Artisan

Darren is one of the top experts in VI development here at NI, and I am looking forward to reading his development tips and ideas for future features!

Maker Faire 2008

2008-10-25T20:05:00.003-05:00

Last weekend I visited the Austin Maker Faire, a showcase of arts, crafts, and engineering. I saw robots, contraptions, musical Tesla coils and more. Quite an event! And LabVIEW was there, too - I saw a group of children using LEGO Mindstorms NXT at a hands-on exhibit. If you're interested in seeing more, I put together a short YouTube video of some highlights, including the life-sized Mousetrap (based on the old board game).

Quick Drop

2008-08-27T17:42:00.003-05:00

Quick Drop is a new feature of LabVIEW 8.6. I don't think I can describe it as well as Jim Kring did, so I refer you to his blog post "Quick Drop is Awesome."

You can also see a video of Quick Drop in action on ni.com.

Darren Nattinger (of Darren's Weekly Nugget fame) created Quick Drop and is amazingly fast when using it. He has configured keyboard shortcuts that he can type entirely with his left hand. His right hand never leaves the mouse!

Linked Tunnels

2008-08-11T11:30:00.000-05:00

Linked tunnels are a new feature of LabVIEW 8.6

Linked tunnels save you from the tedious process of wiring through frames of a case structure when you add new frames or when you add new tunnels to a structure that already has multiple frames. It's easy. Just right-click on an output tunnel and choose an item from the Linked Input Tunnel shortcut menu. You can create the link and wire all the unwired cases, or just create the link. After that, as you create new frames in your case structure, LabVIEW will automatically wire the linked tunnels. This feature also works on event structures.

NIWeek 2008

2008-08-07T16:05:00.000-05:00

NIWeek 2008 is finished and I want to thank everyone who attended. It was a fun and interesting conference. I especially want to thank those of you who told me that you read my blog! It was great to meet you in person! And, yes, I will try to post more often. :-)

Slightly off-topic... does anyone know of any research in the area of seating fragmentation for large groups of people? I have a hypothesis that we'd get more useful seats in the same space if we left more rows open, even though we'd have fewer chairs. (I can't help pondering this; there's something about the engineering mind that detests inefficiency, even in keynote seating arrangements).

Speaking of the engineering mind, have you seen the "An Engineering Mind" videos on YouTube (that they showed before the NIWeek keynotes). Yeah, I know that guy. :-)

Safe journey home to all our visiting friends!

Breakpoint Manager

2008-08-06T15:10:00.000-05:00

The new Breakpoint Manager in LabVIEW 8.6 allows you to easily see all the breakpoints you have set on all VIs in memory. To see it, select the View menu and choose Breakpoint Manager or right-click on a wire, structure or node and select Breakpoint Manager from the Breakpoint shortcut menu. From the manager window you can quickly go to the diagram where the breakpoint is set by double-clicking on the breakpoint in the listbox.

The buttons along the right allow you to enable, disable and remove breakpoints, as well as select all breakpoints.

The ability to disable breakpoints is another new feature. This can be very useful when you need to visit breakpoints in a particular order, which can be done by enabling the second breakpoint when you hit the first. Disabled breakpoints are saved with VIs, which means you can also use them like bookmarks.

Automatic Block Diagram Clean Up, One of the New Features of LabVIEW 8.6

2008-08-05T14:41:00.000-05:00

"Clean up diagram" has changed the way I use LabVIEW.

After years of learning to keep my diagram tidy as I develop it, I now find that I can concentrate solely on functionality and click a button (or use the ctrl-U keyboard shortcut) whenever things get messy. LabVIEW rearranges everything: nodes, structures, wires, etc. I also use it right before I save my VI. It's fast. It's easy. It's really slick.

Of course, it's not a complete panacea. So far, I use it only on "leaf-level" subVIs because I often have design patterns in my higher level VIs that I want in a particular layout. For example, I like having my producer loop above my consumer loop and automatic cleanup sometimes flips them around.

My one complaint with the first release of this feature is that diagram items that don't participate in data flow get "pushed out" to the edge. That means free labels get pushed to the side instead of staying near the code they comment. This is another reason why I tend to use block diagram cleanup on smaller subVIs, because they're likely to have only a single comment for the whole diagram.

Here are the questions I anticipate many will ask about this feature:

Q: Is it fast?
A: Yes, I've been impressed with how quickly it cleans up diagrams.

Q: Can I undo?
A: Yes. If you don't like the results, you can undo the block diagram cleanup with one Ctrl-Z.

Q: Can I tweak the parameters?
A: Yes. Look in Tools>>Options under Block Diagram: Cleanup.

Q: Can I clean up a portion of my diagram automatically?
A: No. It operates on the entire diagram, not a selection.

I don't think any description of this feature can really do it justice. I encourage you to get a copy of LabVIEW 8.6 and try it out for yourself!

LabVIEW 8.6

2008-08-03T16:42:00.004-05:00

National Instruments and the LabVIEW R&D team are proud to announce the release of LabVIEW 8.6. You can find further details on ni.com and in the new features webcast by LabVIEW Product Manager Mike Neal.

My NIWeek 2008 Plans

2008-07-31T15:00:00.004-05:00

I'm really looking forward to NIWeek this year! I recently bought an iPhone and plan to make the most of it at the conference. I will be blogging from the convention center and I'll be on Twitter as well.

On Tuesday evening I'll be hanging out at The Iron Works BBQ with some folks from LAVA, OpenG and NI. If you'd like to join us, there's still space available. Just add yourself to the evite and pay the organizer (Christopher Relf) $39 via Paypal, then come to The Iron Works, a short walk from the convention center, and enjoy all-you-can-eat BBQ. There are even door prizes!

I'm not presenting any sessions this year, but I will be one of the volunteers at the "Ask the Experts" booth in the Expo hall on Tuesday from 5:00 PM to 6:00 PM. Feel free to stop by, say "hi" and tell me what you love/hate about LabVIEW.

Memory Lakes

2008-07-08T21:25:00.002-05:00

Bob Hamburger started a new LabVIEW Insights blog with a great post about Insidious Memory Leaks. As he explains, it is important to avoid open/obtain/create operations inside a loop without corresponding close/release/destroy operations.

However, I am a little uncomfortable with calling the problem Bob describes a "memory leak." A memory leak is when a program allocates memory and then loses track of it, failing to ever deallocate it. LabVIEW, however, manages memory allocations for you*. If your VI opens a reference and never closes it, LabVIEW will automatically deallocate it when the VI stops executing. (I mentioned this automatic deallocation in my post about VI References).

The automatic deallocation doesn't help anything while VIs are running, which is why rampant extraneous allocations like opening references inside a loop will degrade performance over time and cause more serious problems when system resources run out.

But this isn't, technically, a memory leak. My colleague Stephen Mercer calls them "memory lakes" - allocating a huge pool of memory for no good reason.

Although perhaps a subtle distinction, I think it's important to maintain as much technical clarity as possible when describing problems like this, to avoid misunderstandings when reporting issues to NI Support (and, eventually, to us in LabVIEW R&D).

- Christina

* - If you call DLLs or other external components that do memory allocations outside LabVIEW's control, those could cause memory leaks that LabVIEW can't do anything about. Also, when I say LabVIEW doesn't leak things, I mean LabVIEW's not supposed to leak them when operating properly, so if it ever is leaking then it's a bug (and a high priority one).

LabVIEW and FIRST

2008-04-17T17:12:00.002-05:00

Do you know how some people have pet peeves? Things that shouldn't really bother them, but do?

Well, one of my pet peeves is writing LabVIEW with the wrong capitalization.

The "Introduction to LabVIEW" topic in the LabVIEW Help expands the acronym: Laboratory Virtual Instrument Engineering Workbench. I don't understand why publications that wouldn't call NASA "Nasa" or FIRST "First" insist in calling LabVIEW "LabView."

Speaking of FIRST, did you see today's announcement? "FIRST (For Inspiration and Recognition of Science and Technology), a nonprofit organization inspiring young people to be science and technology leaders, has selected the National Instruments CompactRIO embedded control platform as its next-generation FIRST Robotics Competition (FRC) robot controller."

Next year's FRC competition will give high school students the option to program their robots using LabVIEW!

I expect soon we'll be seeing these students joining us in our online communities. I hope you'll join me in welcoming them!

What is VI Server?

2008-03-30T13:22:00.004-05:00

After my last post, I got a question from some new LabVIEW users: "What exactly is VI Server?"

In a strange coincidence of timing, there is brand-new session for NI's LabVIEW Developer Education Day that covers VI Server in detail:

Build Plug-in Architectures and Custom User Interfaces with VI Server goes into detail on using VI Server technology to alter the properties and methods of applications, as well as how to build plug-in, extendable architectures. Demos include creating user interfaces that restrict access based on user or application status, advanced graph displays, and creating executables that can be built on after creation.

You can check the locations and times for this free event at http://www.ni.com/devday/.

It's a great session, but since not everyone will get to see it, I will try to answer the question in my own words. The VI Server features of LabVIEW give you programmatic access to the properties and methods of controls, indicators, VIs, and even the LabVIEW application itself.

It's pretty powerful stuff. You can use it to show/hide controls, change the window style of your VI, run VIs locally or on other computers, and much more.

The general distinguishing feature between VI Server and "normal" VI diagram code (which typically deals with manipulating data) is the use of VI Server references. You open a reference to the item you need to use (e.g. VI, control, or application), you read/write properties or invoke methods, and then you close the reference. As I noted briefly in my last post, you have to be careful about closing references correctly. LabVIEW will automatically close references when your top-level VI stops running, but erroneously open references can cause problems while your VIs are running, including excessive memory usage and holding unneeded VIs in memory.

VI Server References

2008-03-05T13:43:00.005-06:00

In today's video, I answer the question "why doesn't the VI in the picture above work?"

Although a seemingly simple question, the answer involves some advanced VI Server topics, including the "lifetime" of VI references.

While putting together this video, I found a lot of other potential topics for future posts (e.g. What's a "This VI" reference? What's the difference between a subVI call, the Run VI method, and a Call by Reference node?) If you have other questions on this topic, please feel free to post a comment and I'll try to get you an answer!

- Christina

PS Here's the same video on YouTube in case the other link doesn't work for you.