LabVIEW Idea Exchange

Provide a way to save and recall sets of probes for a running application.  A developer could then provide sets of various probes that would help the end user.  The superprobe would remember the VI paths and locations in the block diagrams of the application's SubVIs and automatically load VIs from disk or monitor existing re-entrant copies in memory.  The superprobe would have a front panel layout, like a global VI, to look like a custom dashboard of important data values in the applicaton.

A Diagram Disable structure lets all the code that isn't inside of it execute but not what is inside of it. I think it would be helpful to put a structure around a snippet of code and execute only what is inside the structure. I usually copy and paste it into a new vi but it would be helpful to have that functionality within the vi i'm working on. 

In Java, any errors/exceptions that a function can throw (to its caller) are listed directly in its signature/declaration.  This would be nice functionality to have in LabVIEW.  Otherwise, the only way to determine which errors a VI can return is to either:

• examine the code manually, recursing through all its subVIs or
• brute-force exercise the VI until you have observed all errors that it might throw in your particular application. 

Neither of these options seems particularly robust or efficient.

It may even be possible for LabVIEW to determine the throwable errors automatically, although at least having the ability to declare them manually would be a good start.  They could be registered through the development environment such that they are stored in the VI file itself.  In this way LabVIEW could summarize all the errors a given VI throws based on those declared within it and its subVIs. I acknowledge that this would likely require a more sophisticated error system than the current error codes (since these may not be known at compile time).  But, I would be surprised if it couldn't be achieved in a similar fashion to Java where all errors are classes that inherit from a common "error" class.

If I'm missing some methodical, pragmatic approach for achieving the same result, please let me know.

 I would love to see an optional input node on the edge of a while loop for loop wait. 

When I build, I like to test each step.  That means that I make a bunch of "debugging" indicators.  Some might prefer probes and breakpoints, but I like the "build as you go" and "don't use too many tools".  The challenge here is that about 80% of indicators that I make, I have to delete.

I wish there were a version of "diagram disable" that is specified in the block diagram, that worked for the front pane, and left me some tiny asterisk instead of the indicator, that didn't hit program execution times, and that when I configure execution the asterisks can be made to disappear. 

This would allow me to revisit my code, to access all of my debugging methods very quickly and intuitively, and to not necessarily change the final layout of the front panel after my debug is done.

It would be really nice if the Flatten to JSON supported more LV data types.  In particular, I find it very annoying that it doesn't support flattening a waveform to JSON since those are very common in most of the measurement APIs.  

In the mean time, I have come up with this little work around, but it really seems like this is something that should be natively supported.

I mean when it's used for indexing array...

It could be really useful if someone wants to skip some initial indexes...
It has already been done?

I would like the option to save data from LabVIEW using the Hierarchical Data Format. This would make it much easier to share data with Matlab and other programs.  

This is a real pain point for us at the moment and drives many of our engineers away from using LabVIEW, quite rightly. The tdms import dll for Matlab is slow and the 3rd party .mat export toolkits for LabVIEW are not sufficiently developed or only licensed for single-seat environments.

I think it would be nice to have a for loop that has an automated iteration constant in the tools/structures pallet.

This would be equivelent to a:  "for <a>  from <begin>  to <end> by <step_size>" statement in Maple. 

When start end by terminals are unwired, the loop should behave as an traditional for loop. 

This loop will produce an array [0.3 , 2.4 , 4.5 , 6.6 ....,4.2]

In other enviroments, such as TestStand, you can change the values of variables at run-time, which is extremely useful when debugging.  It would be really nice if you could dothe same thing with the values on wires in LabVIEW.  Perhaps this could be implemented by allowing you to change the value of a wire using the Probe Watch Window or, if that isn't possible, there could be a separate window altogether such as a dedicated variables/watch window.