LabVIEW Wiki - User contributions [en]

Style Guide

2007-12-26T13:29:04Z

Ackbeet: Additional Reference.

Originally there existed a document entitled "LabVIEW with Style" -- A Guide to Better LabVIEW Applications for Experienced LabVIEW Users", authored by Gary W. Johnson and Meg F. Kay. Consider this document to be nominally obsolete. It is on the CD-ROM with the book "LV Graphical Programming" but was lost from the Info-LabVIEW ftp site with a great directory shuffle there some years ago (it was in a now-absent DOCS directory). The document does not appear to be on the NI ftp site either.

There is a much better reference available now. If you buy the Professional version of LV6.0i, you get a printed manual called Development Guidelines. Even if you just get the non-pro version, install all the PDF manuals and you will find the same document as DEVSTYLE.PDF. It's a wonderful little book, written by the VI Development team at NI with input from many... including that ancient style guide that Meg and I worked up. Highly recommended.

Also on the NI website a search for STYLE GUIDE will locate the "Rules To Wire By" series by Rande Johnson. It's a great series, and may well meet your needs. Lots of wisdom there.

There are more works in progress on this subject, including one or more books (NOT by me!). And NI will keep revising the Development Guidelines book.

One book that came out recently is "The LabVIEW Style Book" by Peter Blume.

[[Category:style guide]]

Numeric

2007-12-26T12:49:02Z

Ackbeet: Spelling and Grammar

== [[NaN]] equivalent for [[integer]] data types ==
NaN is defined only for floating point numbers. In a [[U32]] all the possible values are actual numbers and there is no place left for a special value that says there is nothing there. If you need an "empty" value in an integer data type you have to pick a value that never appears in your particular application (if there really is one) to serve as a flag. In other words there is no "empty value" in integer data types.

'''A useful trick:''' In most cases, zero or -1 are used as the magic sentinel value for integer work. But sometimes you'd like to use "largest possible integer" as your sentinel value because zero and -1 are actual values, and you don't expect to ever actually use the large end of the spectrum. But nobody actually remembers the largest possible integer, and even if you look it up (it is in the Context Help for an integer wire, by the way), typing it is annoying. Solution:
*Drop a Numeric constant on the block diagram and set it to be your type of integer. Then type a long string of 9s into it, such as "99999999999999999999999999999999999999999". LabVIEW will automatically change this to be the largest possible integer storable in your data type. If it doesn't convert and you still have the long string of 9s, then you didn't type enough 9s. This can happen if you're using unsigned 64-bit integers... those things are HUGE!
*Another way to get the maximum value is the following snippet:
[[Image:GetMax.png]]

Test a floating point wire for NaN by using [[Image:Nanfunc.png]] from the Comparison pallete.

== Comparing real numbers ==
What you need is a comparison that assumes that equal is the same as close enough. One way is to define an epsilon and check to make sure that your error is greater than that epsilon where epsilon is dependent on the type of number (single, double, extended) that you are using. For example, to compare A greater than or equal to B (as double precision) you could use as your test the following:

A-B >= -1e-17*(A+B)/2

Or maybe 1e-16 to be safe. To be really careful use 2^-31 as your criterion. This handles the case where A is already 10^-31 in magnitude or when both variables are zero.

A simpler method is to multiply your numbers by 10 to make integers, round them and then compare. In fact you can multiply by whatever power of 10 desired.

This is *not* a bug. It appears as a result of the limitation of finite computers. There is not now and never will be a fix. The main fix is to the programmer. As a caveat, do not ever, ever, ever compare real numbers. They are uncertain within the least significant bit.

These uncertainties arise in several situations. Another example where this must be taken into account is the output of both"Format & Strip" and "From Exponential/Fract/Eng"; enter a string of "0.1" and you get the number: 0.10000000000000000100. You cannot represent 0.1 as a finite binary string.

As to a wish for a finite conversion width, nope. The problem is that the conversion does have a finite width. It is that factor of 5 in base 10 numbers that makes a finite decimal be an infinite repeating binary string. You can represent all numbers that can be formed as sums of 1/2, 1/4, 1/8, 1/16, 1/32. Unfortunately 1/10 can only be approximated. The wish seems to indicate that the binary is converted to base 10 (with a finite conversion width) and then compared. Actually it is all compared in binary, when you display it, you can convert it to 10 digits or what ever you want.

In summary, any binary representation will be approximate. How approximate is based on the word length. It is that factor of 5 in base 10 numbers that gets us. It appears that you have 17 digits of accuracy which is about right for a double precision number. Extended have more, singles have less. That is mathematical reality. Computers are not idealized mathematical machines. If it was easy everyone would be an expert. Knowing how things are treated by the underlying hardware can keep one from having these problems.

[[Category:numeric]]

While loop

2007-12-26T12:46:23Z

Ackbeet: Spelling and Grammar

== What does 0ms wait function do in a while loop ==
If you have multiple loops in your application that don't need to run as fast as possible, then placing a 1ms delay will limit your loops to at most 1000 iterations per second. Without a delay, the loop rate can be in the millions of iterations per second range depending on what is inside it. So that means that your CPU has about 1/1000th as much work to do and can go off and tend to other tasks. If your loop was already taking several ms, then the 1ms delay is likely in parallel and it won't affect the loop speed noticeably. So placing the delay in the loop can drop your CPU usage noticably and allow time for the OS to do other work like send messages that your application may be waiting for, etc.

But what does a wait of 0 ms do? Let's consider the LV execution system to be a xerox copying machine. Everyone that has something to copy heads for the copying machine and lines up. If you have never had the pleasure of waiting at a copy machine, then consider any other time consuming task where people wait in line. Everytime a LV diagram executes a wait function, it is like releasing the copier and staying out of the line for some time delay. After the delay has passed, you will get back in line to make your next copy. A wait of 0 ms is like immediately going to the end of the line to let a smaller copy-task take place. If nobody is in line behind you, you immediately start your next copy task. If someone is in line, it lets them take a turn.

This 0 ms wait is a pretty cool little trick to make LabVIEW loop parallelism less chunky. It naturally adds some overhead because the loops have some setup time, but when the loops are doing significant work it is tiny. Use it whenever you think you need to, but beware that if some loops don't have any delay, they are still going to

hog the CPU, and the wait of 0 ms may turn into much larger waits because the loops with no waits play by different rules.

== Is the while loop really a while loop? ==
No. Strictly speaking the while loop is a "do while" (in C) or repeat until (in PASCAL) programming structure. In other words the loop always executes at least once, and the Boolean test for continuation is done at the end of the loop execution. With a true while loop in a text based program the test is done prior to executing any of the commands contained within the loop.

To create a "real" while loop wire the output of your terminating condition to a case structure surrounding the rest of the code within the loop.

This is of course true, but then there is no real difference between a while loop as you describe it and a for loop in C either. Of course the syntax changes but the functionality is really equivalent.
And instead of putting the case structure inside the while loop you could just as easily put the while loop in the case structure and get the same behaviour and IMO it looks more clear what is happening.

Also true, but then you lose the advantage of having a shift register from the loop hold variable(s) that are part of the exit test, unless you wrap the whole thing in another loop.

[QUOTE]
and the Boolean test for continuation is done at the end of the loop execution.[/quote]

This is a little misleading, particularly for new [[LabVIEW]] programmers. The boolean test for continuation is done as soon as possible... it only waits until the end of loop execution if there is a data dependency. With no dependacy, the loop will decide whether to execute again before/in parallel with any other code in the loop.

I have seen plenty of people getting one extra iteration than they expected because of this.

[[Category:structures]]

LabVIEW

2007-12-26T12:35:24Z

Ackbeet: /* Versions */ (current)

[[Image:LabVIEW_Logo_Vertical_4c.jpg|right|thumb|200px]]
== What is LabVIEW? ==
LabVIEW is a fully featured programming language produced by [[National Instruments]]. It is a graphical language quite unique in the method by which code is constructed and saved. There is no text based code as such, but a diagrammatic view of how the data flows through the program. Thus LabVIEW is a much loved tool of the scientist and engineer who can often visualise data flow rather than how a text based conventional programming language must be built to achieve a task.

==Purchasing==
LabVIEW is developed and sold by [[National Instruments]]. This is an American company with distribution via international offices and [[National Instruments]] Alliance members. For more details check out the [[National Instruments]] Web site

== Versions ==
There are many versions of LabVIEW still in use, although the earlier versions are constrained to hard core dedicated enthusiasts. We have heard whispered mention of the use of Version 3 and there are many active Version 4's in circulation. More recent additions to the legacy software bin are versions 5.0, 5.1, 6.0i and 6.1, while the current version as of December 2007 is 8.5. In addition there are demo versions available from [[National Instruments]], as well as a student versions of 5.0, 6.0 and 7.0 available from Prentice-Hall.

From version 6.0 onwards NI released the product formerly known as BridgeVIEW as a LabVIEW plugin module called the Data Supervisory and Control module (DSC) and with the advent of [[real time]] boards and the release of the [[Fieldpoint]] real-time network module, there is also a module that allows writing of code for [[Portal:embedded|embedded]] processors referred to as the [[real time|Real Time]] module (RT). Lastly, there are two new additions to the LabVEW world in the [[PDA]] module (for writing code for PocketPC and PalmOS) and the [[FPGA]] module for writing code for Field Programmable Gate Arrays (LabVIEW on a chip!). These modules now keep track with the current LabVIEW version.

== OS Support ==
LabVIEW source code and development is supported by Windows 9x/2000/NT/XP, [[Apple|Apple Macintosh]] (including X), PowerMax OS, Solaris, HP-Unix, Sun, [[Linux]], the Pharlap RTOS, and VxWorks RTOS (Real-Time Operating Systems, found on [[National Instruments]] embedded controllers). Executables can be compiled under their respective development systems to run on these platforms. Code developed under one platform can be ported to any of the others, recompiled and run.

[[PDA|LabVIEW PDA]] can run on handheld devices, such as Microsoft Windows Mobile for Pocket PC devices.

There are of course exceptions to every rule. In this case platform specific sections of the LabVIEW development system will not be transferable. For example, Active X which is Windows 9x/NT specific. Furthermore, certain third party device drivers or LabVIEW toolkits installed under one system may not necessarily run or be recompiled on a different operating system.

== The Future of your LabVIEW Code ==
LabVIEW has become widely used in so many applications it is hard to think about it going away. It would only disappear if it stopped being used so widely.

From a message posted to Info-LabVIEW in Feb '97:

[quote]> > In buying CINs (or LV code) for that matter one must check the reliability
> > of the company and if it will be in business later. Some responsible
> > companies put their source code in escrow to be given out if the company
> > goes belly up. Some don't. What would we all do if NI stopped supporting
> > LV on our favorite platform? We bought it to run on a given platform and
> > it does but we have a big investment in code now and unlike C I can't go
> > out an buy a "different" compiler! I guess this begs the question to some
> > one from NI out there.... "Is the source code for LV in escrow or could we
> > be in deep yogurt if NI goes out of business (not that I am suggesting that
> > this is likely!)?"[/quote]

Greg McKaskle writes in response:
[quote]
>NI's quarterly report was posted last week, symbol is NATI, and I think
>that you will agree that NI is still growing strong. Never-the-less, the
>LV source code is escrowed, and if someone wants details they can
>contact the NI legal department. NI manufacturing is ISO certified and
>all hardware drawings as well as software source code is kept under
>revision control.[/quote]

The fact that LV is escrowed and is ISO certified means that it can exist beyond the existence of NI. If this is of interest to you or your company you might want to contact the NI legal department for a letter explaining the exact circumstances that would release the escrow.

== See Also ==
*[[LabVIEW Bug Reporting]]
*[[LabVIEW tutorial|LabVIEW Tutorial]]

[[category:LabVIEW fundamentals]]

XNodes

2007-12-26T12:30:53Z

Ackbeet: Spelling and Grammar

'''XNodes''' are a technology built into [[LabVIEW 8.0]]+ that allows dynamic edit-time macro support. XNodes are [[Library|Libraries]] that feature several "Ability" [[VI]]s which consist of various events and methods of the XNode.

{{See also|XNodes:List of XNode Abilities}}

==XNodes used in LabVIEW 8.2==
<br />
{|cellpadding="2" border="1"
|-
| Class Aggregate Handler? || ([[vi.lib]]\Utility\AggHandler\Cls_AggHandler.xnode)
|-
| Class Grow Array Handler? || ([[vi.lib]]\Utility\XGrowArr-llb\Cls_GrowArr.xnode)
|-
| Regular Expression || ([[vi.lib]]\regexp\Match Regular Expression.xnode)
|-
| Shared Variables || ([[vi.lib]]\variable\varXNode.llb\vi.lib\variable\varXNode.llb\varXNode.xnode)
|-
| Timed Loops || ([[vi.lib]]\Platform\TimedLoop\XDataNode\XDataNode.xnode)
|-
| Database Variant To Data || ([[vi.lib]]\addons\database\_DB Variant To Data\Database Variant To Data.xnode)
|}

== Ability VIs ==
:''Main Article: [[XNodes:List of XNode Abilities|List of XNode Abilities]].''

== XNodes in the Development Environment==
XNodes can be added to palettes as if they were plain [[VI]]s; however, the icon
that is displayed in the palette is that stored in the .xnode file and not the image created by the [[Image (XNode Ability)|Image]] Ability vi. It is possible to set the icon in the .xnode file by manually editing the xml file. One way of doing this is to create a LabVIEW library (.lvlib, not .llb) from within LabVIEW and edit the icon for this library. Then making sure that all references to the Xnode are closed, open both the .lvlib file and .xnode file in a text editor and copy across the <Property Name="NI.Lib.Icon"... line.

==See Also==
{{portal}}
*[[External Node]]
*[[XControl]]
*[[VI scripting|VI Scripting]]

[[category:xnode]]

Math and Signal Processing

2007-12-15T19:13:04Z

Ackbeet: Spelling and grammar.

LabVIEW Full/Professional Development System has more than 600 VIs for mathematics and signal processing. In addition, there are about ten add-on LabVIEW toolkits/modules for math and signal processing. The LabVIEW analysis tools cover many mathematics and signal processing fields such as linear algebra, polynomials, curve fitting, statistics, optimization, joint time-frequency analysis, time series analysis, wavelet analysis, digital filter design, system identification, image processing, etc.

*[[MSP_Overview|Overview]]
*[[MSP_Function List|Function List]]
*[[MSP_Function Reference|Function Reference]]
*[[MSP_Application Notes|Application Notes]]
*[[MSP_Tutorials|Tutorials]]
*[[MSP_Sharing Success Stories|Sharing Success Stories]]