LabVIEW Idea Exchange

Community Browser
cancel
Showing results for 
Search instead for 
Did you mean: 
Post an idea

While LabVIEW supports units (partly), the lack of ability to display them nicely in the Unit Label can make for ugly front panels where they're used.  A couple of small changes that would improve things would be:

  • to render "^2" as "²" and "^3" as "³" (that covers probably 99% of unit exponents used)
  • to render "u" as "µ"

The Unit Editor doesn't need to change, nor the way units are typed in, but these changes could then be automatically applied.  All three characters exist in most fonts.

 

I have a need to keep two string indicators lined up as the user scrolls one of them. It would be great if I could use the event structure to capture scroll position. It doesn't look like that is an option. I didn't see this posted yet.

 

String.PNGstring2.png

 

When dragging a snippet onto the block diagram, its code should remain selected so we can immediately drag (or use the arrow keys to move) it to a better location.

 

Currently, the new code is not selected and it is nearly impossible to separate it from the existing code, for example if a complicated snippet is dropped on an already complicated block diagram.

 

(Not everybody has a gigantic screen to resize the existing BD for plenty of whitespace. I also often only have a small strip of the BD showing, with the explorer window containing the "droppee" on top. Dragging the snippet to the BD invariable ends in a complete mess.)

 

 

When searching for text, the results are returned as a comma delimited string. If you are interested in finding a result based on location or type, you have to eyeball the results to find what you want. Since the data is already delimted, each piece should be placed in its own column which can then be sorted. Also, the ability to filter the results based on an expresssion would further help narrow down the results.

 

20121i19DC718199D8B5D6

A tabbed wiring diagram comment field. Not a constant, just a placeholder for free text.

 

17661iA4DF90F9D4D1C4A7

 

 

One thing prevent our company to upgrade to newer labview is that the run-time engine gets too big. Even I really like the features in later version, I still have to save the files back to 7.1 then to 7.0 to build application installer. Under 7.0, the run-time engine is very small, and the installer is less than 10MB and I can easily email the program to customers. In version 8.0, the run-time engine is 65MB and now the latest version is well above 100MB.

 

What I would like to see is that application builder get smart, only pick what is needed and build slim app.

Populating the Tree Control with items takes very long time.  I suggest improving the performance of a tree control.  Many other applications have tree controls that are populated in a small amount of time, so it should be possible with LabVIEW.

 

I know of three ways to populate a tree control.  The first is to individually add items using the Add Item invoke method.  This method takes a very long time.  Adding 15,000 entries took over 180 seconds.

 

The second way is to use the"Add Multiple Items to End" invoke method.  This took over 20 seconds for 15,000 entries.

 

The third way is to programatically respond to the user expanding an item in the tree and populating only as necessary.  I assume that this is fast, but it seems like a lot of work to do every time a tree control is used that could have a lot of items. Maybe LabVIEW could improve performance by using the third approach internally for the programmer. 

 

Currently I am hesitant to use a tree control because of performance.  LabVIEW is a great product, and making the tree control perform better would improve LabVIEW even more.

 

This would replicate the ability of the standard Index Array function to extract a subarray from a multi-dimensional array. Currently both indices must be wired, which only selects scalar elements.

ArrayIndexInPlace.png

 

Another related enhancement that may be useful is to provide the equivalent of "Array Subset" on the In Place Element Structure.

 

I have become a huge fan of the compound arithmetic node, and there are a growing list of good ideas on this Idea Exchange that involve adding invert capability to more boolean inputs/outputs.  Unfortunately, the circles used to show that an input/output is inverted are too small for my taste which makes them easily missed by the untrained eye.  Filling the circles black is one possibility, but there is room between the terminals to at least double the size.  With a more prominent indicator that a node is inverted, I will easily support adding invert capability anywhere it makes sense.  

 

I know that most of the wildly popular ideas here involve making things smaller, hopefully with some of that reclaimed real estate we can make room for some slightly larger circles.  

Related to this idea, when you right-click on an array wire, LabVIEW shows the Array Palette.  However, many of the operations for the element type are often polymorphic.  As such, it would be useful to show the palette for the array's element data type as well.  The screenshot, below, shows what I mean:

 

 

2.png

The "right-click...replace" option has few choices, typically the home palette of the current selection if available and "All Palettes".

 

Quite often, I need the entry "Select a VI...", all down at the bottom after selecting "All Palettes".

 

Suggestion 1: Add "Select a VI..." to the first menu, see image.

 

Especially when benchmarking or trying different algoritms, I often like to replace the current VI with another VI that is already in memory. 

 

Suggestion 2: Also add a "VIs in memory", which would allow picking from list of all VIs in memory (except things located in VI.lib or in the standard palettes).

 

Here's an image how it could look like:

 

 

 

Message Edited by altenbach on 07-05-2009 09:35 PM

Inspired by Altenbach's Boolean constant design, I thought of the following....

 

When we have a SGL or a DBL constant on the block diagram, we have to right click, selece "representation" to find out exactly what type it is.  Why not have some indication as to the actual data type which could conveniently act as a menu for changing the data type.

 

BD Constant Data Type.PNG

 

The same thing goes for U8, I8, U16, I16 and so on.

 

Shane.

 How many developers are using a splash screen for their applications ? Shouldn't this be a straightforward task even for beginners ? NI should provide an easier way to implement this technique.

Feedback nodes can reside entirely inside one case of a case structure. This simplifies coding if feedback operations are limited to one single case. Unfortunately, there is no easy way to retain the output once the loop has finished if the last iteration executes one of the other cases. As a result, we might see local variables or even indicators inside the case containing the feedback node, defeating the "in place" purpose. For a "wired" solution, we need to place the feedback node outside the case and wire across all other cases (image top).

 

I propose an output terminal that sits on the output edge of a loop and contains the contents of the feedback node at the time the loop finishes. Typically that would be the edge of the same loop that contains the initializer terminal (image bottom), but it should also be available for globally initialized feedback nodes and on other loop boundaries surrounding the feedback node (selectable).

 

I am sure this idea needs to be worked out in more detail, so this is just an initial concept. 😄

 

 

 

 

Message Edited by altenbach on 06-16-2009 09:34 AM

It seems that if you have a VI (or function) inside of a disabled frame of a Diagram Disable Structure or Conditional Disable Structure then the Find and Find All Instances features in LabVIEW will not report them. I'm OK if this is the default behavior, but maybe the Find dialog should have an option/checkbox to search inside of Disabled Structures.

 

Note: This is really important for cross-platform and embedded target development where there's lots of use of Disabled Structures.

Jim_Kring_0-1607621796261.png

 

Instead of doing all this:

Captured1.png

I would like to be able to just drop a VI on the Start Asynchronous Call node, and get this:

Captured1.png

There should be an option to fully enable optimization when building an application as to automatically remove performance impacts caused by diagram elements that shouldn't cause any.

 

As summarily declined by NI, this idea

http://forums.ni.com/t5/LabVIEW-Idea-Exchange/Improve-Diagram-Disable-performance/idc-p/3253939#M34372

 

shows that unless you manually go over ALL your VIs disabling debugging, Diagram Disables (that are supposed to not avoid executing some code!) you'll suffer a performance impact.

 

It is preposterous to expect the users to manually disable/reenable debugging on every single VI when building an application.

 

Please add an option to enable full optimization.

 

Untitled.png

This is a follow through for Zekasa's Idea posted here. It was suggested that the function be a separate one, which I agree. I would like to see this in LabVIEW's basic package, without adding things onto the install, or coding it.

 

Search 1D Array Until Done.png

 

The property AllVisInMemory does not return in its list the clones of VIs that are running. It would be helpful to have this included.

We can easily replace a FOR loop with a WHILE loop and vice versa and most features are retained in a reasonable and expected manner. (For example if there is an indicator wired to [i], it will still be connected after replacement).

 

There is one annoying exception: The conditional terminal is completely ignored.

 

For example:

 

Case 1 (FOR -> WHILE)

We have a FOR loop with a conditional terminal wired to a boolean condition. If we replace that FOR loop with a WHILE loop, we probably would expect the conditional terminal be still connected in the same way. This is not the case. We get a dangling broken wire and a new, now disconnected conditional terminal.

 

Case 2 (WHILE -> FOR):

We have a WHILE loop and replace with a FOR loop. If the conditional terminal is wired to some real code, it should automatically retain the conditional terminal in the same place. (If the conditional terminal is not wired in the while loop, the FOR loop should not show the conditional terminal).

 

As a practical example, let's look at my old inverse erf draft posted here long ago. One flaw is the fact that there is no limit on the number of iterations so it might get stuck with a misbehaving function. In the old days, we would add another comparison with [i] and OR to the termination condition (lots of extra code, new loop needs to grow in size). A cleaner solution is to replace the while loop with a FOR loop, leaving the conditional terminal in place as-is, and wire a reasonable iteration limit to N (little extra code (just one diagram constant!), loop can remain at the same size). Here Case 2 would simplify the transition.

 

SUGGESTION: If we switch loop flavors using the "right-click..replace" mechanism, the conditional terminal wiring should be retained in a reasonable way.