LabVIEW Idea Exchange

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

I sometimes find it easier to understand a block diagram if I colour the background:

 

 structureDifferentiation1.PNG

 

Which got me thinking... what if I had something like this:

 

allWhite.PNG

 

It is not immediately obvious to me the levels of the structures... so perhaps I should colour the levels progressively darker:

 

multiLayer.PNG

 

Now it looks like you have multiple layers of tinted glass stacked up, and gives it an almost 3D look! I can now immediately tell which structure is innermost.

I think the enviroment should have the ability to specify colours of structure depth:

 

options.PNG

 

What do you think?

I use typdefs for almost any data type I define in a program.  Most of the time I am concerned with the data only so a standard typdef is perfect.  sometimes I want to also have the look (properties) of the cluster or control stay the same throughout the code.  A strict typdef does this, but then causes problems like I cant change the properties at runtime.

I would like the ability to change the master typedef and update all instances to PROPERTY changes (ie size or color scheme...).  The current work-around is to temporary save the typdef as strict, close the typdef (causes the propertie changes to update) and then reopen the typdef make it a non-strict typdef and then save and close again.

 

There should be a synchronize option on typdefs.  Turn it on and the look of the typdef will be synchronized, turn it off and you have a standard typdef.

 

 

If you have disable symbols that switches code into debug or demo mode etc....it is critical that you know about them, and see what they are currently set to.

 

Conditional disable symbols are too hidden; to see what they are and edit them you need to right click the project, select properties, and then select the symbols option from the properties window...

 

Idea 1: Put them in a folder in the project list instead and allow the user to edit their value directly in the project window.

 

Idea 2: In addition all symbols should have a setting that says what their value should be in a built application, this could be settable either by double-clicking the symbol in the symbol folder, or by showing the two values directly in the project window in two separate editable columns.

 

This would also eliminate the need for this related idea.

 

PS. The suggested symbols folder has another related idea - namely the idea for an equivalent to "DEFINE" in C. Definitions could be a folder much like the proposed symbols folder, or they could be merged.

 

 

Would be great to have an easy access to the mouse scrolling wheel event within any control. In the example below we could zoom in a XY Graph by using X.Range and Y.Range Property, that could be also created as an Invoke Node for this kind of control. I already did it with a user dynamic event and it works great, but took much coding time. I needed to code an event case for "Mouse Enter";"Mouse Leave" to register/unregister the event...

scroll.PNG

When I need to pass a data from a loop to another I need to create an indicator and local variables which create copies in memory for each variables. So we have at least 3 copies in memory for the same data. One for the wire itself, one for the indicator and one for the local variable. Why there is no kind of pointers which LabVIEW could handle from under the hood with the wire's memory adress. Imagine something like that. Then we don't need to use a hidden indicator only for data passing.

pointer.PNG

This example doesn't look very clever but you can see what I mean. 

I love the new quickdrop plugins!  I've written a few that I use all the time.  (Reset front panel to origin, emergency abort vis, etc.)  The only thing I don't like is the requirement to name the plugin the same as the letter that will activate it.  Since my 'q' plugin and 'shft-q' plugin have to reside in the same vi, it is a bit harder to share plugins with others.

 

I would like to have the ability to give the plugins a descriptive name and have a configuration utility where I can assign hotkey combinations to each of my plugins.

I recently had to graph some 3D data, and found it more trouble than anticipated.

It would be great if there was a graph similar to the XY graph, but for 3D.

Instead of clustering just a 1D x-array and a 1D y-array, you could cluster a 1D z-array as well.

Then send the whole cluster to the XYZ graph.
Or 3 inputs, 1D arrays each would work.

 

It is difficult manipulating the data for the current required inputs of:

- 1D x array

- 1D y array

- 2D z matrix

I spend time making the size of my front panel and block diagrams fit my code well.  Unfortunately everyone once in a while I will hit ctrl+T when I'm trying to press ctrl+R to run my code, and it of course changes the dimensions of my windows.  I try to undo the operation, but it does not work properly (or as I would want it to).  It moves it back to its position, but the dimensions are all wrong still.  Very frustrating.

 

I propose that Undo reverts the panels to their pre-tiling size.

It might be nicer to have a simpler interface to read/write routines for class references.  The fact that the bundle/unbundle is now an asynchronous operation needs to be displayed as does some sort of error terminal.

 

ShortClassReferenceIdea.jpg

It would be very useful to have a way of automatically create subvis when a single vi become too large. What we usually do is :

1. Select the portion we want ton encapsulate in a new vi.

2. ctrl-X.

3. Create new VI, save as, chose name, change icon.

4. ctrl-V.

5. Connect the front panel.

6. Add the new vi to the original diagram.

7. Connect the new vi.

8. Debug mistakes.

 

I think steps 2 to 8 could be automated with a single function (e.g. 'transmute selected code into a single vi'), saving a little time many times.

CaseError.PNG

Would be nice to have an element selector with error case. No need to wire an unbundle element to connect the error code, then the Case structure becomes like a numerical values case selector.

 Variant-Tunel.PNG

Wouldn't be nice to have a configurable tunel in case structure which receives a Variant?

 

Regarding each case we could specify which datatype it is, by right-clicking the tunel and getting a new window to define the type.

 

Then we wouldn't need to wire a "Variant to Data" sub-vi and a control/constant to define the datatype.

All property nodes should use enums to make the code readable and not required to open help every time you need to set a properity.  I find myself creating typeDefs for my self so I don't have to look up what the properity does and to make my code easier to edit.  Example provided is to disable a control on the front panel.  This is in the LabVIEW style guide Smiley Wink

 

propertyNodesEnums.PNG

LabVIEW loops are quite flexible and allow me to do just about anything I want, but I often find myself writing the same code over and over again trying to iterate across different data types and data structures. There are several situations where smarter looping constructs could greatly simplify my code. One simple example is stepping by a delta between a minimum and maximum value. Currently, I have to calculate the number of iterations required ahead of time (for a for loop) or do a comparison with the maximum (with a while loop) and use shift registers to maintain the intermediate value. I'd like to be able to wire the max, min, and delta to my loop and have LabVIEW do the required calculations for me. The iteration terminal could also adapt to the proper data type given the input parameters. Perhaps the iteration terminal would have two outputs, one with the current iteration count and the other with the proper iteration value.

 

stepped-loop.PNG 

 

Another useful feature would be allowing me to wire a queue reference to the loop count terminal of the for loop and having it automatically pop each value from the queue and feed it to me through the iteration terminal. It would do this until there are no values left in the queue or until the code stops the loop. One could write an algorithm that pushes new points into the queue from within the loop or push the current value back onto the queue for later processing.

 

I'm sure there are other useful iteration strategies that are fairly common, please share them with the community

This suggestion is to have an "inverse" Disable Diagram or an Enable-this-part-of-the-code-only Diagram (it would have to have a better name than that :)). This feature would let you disable all your other code except for what's inside this structure. I think it'd be useful in troubleshooting and focusing in on parts of code.

This would allow you to drop complex bits of code right on the block diagram just like you would a sub-vi.

Sometimes I accidently click on the conditional terminal of a loop and accidently change its stop condition.  Then I may need to look at the code to figure out which condition it is supposed to stop on.  If that conditional terminal had a label, that label could be set by the programmer to say which state is desired and quickly ensure the proper state is set.  This would also help someone else who came along and looked at the code.

 

I currently set the label for Boolean constants for this same reason.

 

More often than not, one location doesn't work for both. Here's an idea:

 

label_loc.JPG

 

Type casting from a number to an enum will use only the first (highest) n bytes that it needs to do the representation.  In most cases I would argue this is contrary to what most people would expect to occur.  To remedy this case, a casting needs to be done on the numeric input before hand so that for example, the number 1 goes to the enumerated value with a number 1. 

 

My suggestion is to have a vi that is specifically designed for typecasting to an enumerated value.  This vi would be free to cast the numeric input, so as to match the enumerated input.  It could also take in an input string, and try to match the string to the strings values of the enumerated type.  I could implement this myself, and might, however it seemed like it might be useful to have that in the same panel as the typecast so that one would be more inclined to use it than the typecast, for enumerated values, and subsequently avoid the problems that come with this unexpected behavior.