However, in LabVIEW 2009 this no longer works.  But, there’s still hope.  It turns out that LabVIEW 2009 EXEs are basically just ZIP archives.

And, you can list the contents of LabVIEW 2009 EXE files, programmatically, using the OpenG Zip Tools library, as shown below:

Note: The image above is a VI Snippet and you can just drag & drop it into a LabVIEW 2009 block diagram (but, make sure to install the OpenG Zip Tools first). Or, download the VI File, here: List LV2009 EXE File Contents.vi

Voilà! Problem solved

I definitely couldn’t live without these handy VIs.

Here’s a short, 5 minute video showing how to use this function:

If you want to give this VI a try, you can obtain it using VI Package Manager (VIPM). Simply select the OpenG LabVIEW Data Tools (oglib_lvdata) package from within VIPM. Once installed, this will add a new functions palette at OpenG>>OpenG LabVIEW Data Tools.  (See here for a quick guide on how to install OpenG on VIPM.)

This VI filters a 1D array, keeping only those elements were corresponding elements in a Boolean array are TRUE. This is a little bit harder to explain with words, than with code, so let’s look at an example of this VI in action. In the simple example, shown below, we are keeping only even elements of the input array. As you can see, the benefit of using Conditional Auto-Indexing Tunnel is that you do not have to do any building or deleting of arrays!

Note: The example, above, may be found in your LabVIEW examples folder, here:
\examples\OpenG\array\Conditional Auto-Indexing Tunnel Example 01.vi

And, here’s an example showing how to filter out elements in an array, without even using a For Loop!

If you want to give this VI a try, you can obtain it using VI Package Manager (VIPM). Simply select the OpenG Array Library (the oglib_array package from within VIPM), you will find the OpenG Array Tools palette in the Functions palette under the OpenG submenu. (See here for a quick guide on how to install OpenG on VIPM.)

NI Version…

OpenG Version…

The “Relative path (.)” input of the OpenG version allows you to avoid some of the extra code required to build a path, relative to the constant (and, if you leave that input unwired, then the function simply outputs the path, in the same way as the NI function). For example, let’s look at a common use case, implemented with the NI version of Temporary Directory.

Now, let’s look at the equivalent code, using the OpenG version.

That’s one less node and one less wire. It’s not much, but it adds up!

If you want to give these OpenG file constant VIs a try, you can obtain them using VI Package Manager (VIPM). Simply select the OpenG File Library (the oglib_file package from within VIPM), you will find the OpenG File Tools palette (and File Constants subpalette) in the Functions palette under the OpenG submenu. (See here for a quick guide on how to install OpenG on VIPM.)

In the simple example, shown below, we are specifying that we want to read from a Configuration File named “setup.ini” which is located in the same folder as the calling VI.

Remember, you can use relative paths as shown, below (for example, if you keep your configuration in a “support” folder):

If you want to give this VI a try, you can obtain it using VI Package Manager (VIPM). Simply select the OpenG File Library (the oglib_file package from within VIPM), you will find the OpenG File Tools palette in the Functions palette under the OpenG submenu. (See here for a quick guide on how to install OpenG on VIPM.)

Let’s take a look at one of the VIs. As you can see, below, the OpenG Wait (ms) function has an error in input and an error out output.

In the simple example, shown below, you can see how we are able to insert a wait between execution of two tasks by chaining (wiring in a sequence) the error cluster wiring between the three VIs.

This is not possible, using LabVIEW’s built-in Wait (ms) function, shown below, which has no error input or output.

One other thing that we did not yet mention, is that the OpenG Wait (ms) function has an input called “Wait on Error” that defaults to FALSE. This means that we can choose whether or not we want to wait, if an error occurs upstream — generally, we will not want to wait, if an error occurs.

If you want to give this VI a try, you can obtain it using VI Package Manager (VIPM). Simply select the OpenG Time Library (the oglib_time package from within VIPM), you will find the OpenG Time Tools palette in the Functions palette under the OpenG submenu. (See here for a quick guide on how to install OpenG on VIPM.)

One of the great things about this VI is that it automatically handles any variety of different end of line (EOL) characters (see wikipedia definition of Newline) that can be found in various platforms (for example: Mac, Linux, and Windows).

Let’s take a look at a quick example of this VI in action. In this example (shown below), we are converting a string with five lines into an array with five elements — one element for each line of the input string.

That’s all there is to it!

Now, you might be thinking to yourself, “How do I get rid of the blank (third) line?” That’s easy! Just use Filter 1D Array (which we learned about in our last article), as shown in the screenshot, below (wiring an Empty String constant to the “items to filter” input):

If you want to give this VI a try, you can obtain it using VI Package Manager (VIPM). Simply select the OpenG String Library (the oglib_string package from within VIPM), you will find the OpenG String Tools palette in the Functions palette under the OpenG submenu. (See here for a quick guide on how to install OpenG on VIPM.)

Let’s take a look at a couple simple examples of this VI in action.

In this example (shown below), we are filtering out all values of +Inf and -Inf from a 1D array of DBL floating point numbers. We simply specify an array of items that we wish to filter out of the input array and Filter 1D Array does the rest.

In our next example (shown below) we will notice that Filter 1D Array is Polymorphic. First, we notice that this example is filtering items from an array of strings (or previous example used a DBL floating point array) and, second, we notice that we are wiring a scalar value (empty string) into the “items to filter” (our previous example used an array of items to filter). You can see in this example that all of the empty string elements were removed from the input array. Very cool!

One other thing that you should also know (that we did not highlight in the above examples), is that Filter 1D Array outputs an array of indices (pointers) of the items that were removed. This allows you to do operations on associative arrays (see wikipedia definition of associative array) — an advanced programming technique.

If you want to give this VI a try, you can obtain it using VI Package Manager (VIPM). Simply select the OpenG Array Library (the oglib_array package from within VIPM), you will find the OpenG Array Tools palette in the Functions palette under the OpenG submenu. (See here for a quick guide on how to install OpenG on VIPM.)