LabVIEW Idea Exchange

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

Add a right click menu item to "Boolean Array to Number.vi" for selection of the output data type. Currently this is buried inside the Properties and is not easy to find.

Almost every time I work on a new test system and start documenting, I can't tell which drivers, add-ons... the code depends on.

The documentation (design description) should at a minimum tell a new developer what drivers, add-ons... must be installed to have the code executable on a development machine.

I've issued a support request on this, but the support team told me that there are no such funtionality in LabVIEW. The Dependencies folder in the project gives you some indications. VI Hierarchy and VI Analyzer also give some indications. The only way to sort this out is to install LabVIEW stripped from all extras and then install one driver/add-on... at a time until your code gets executable.

 

My suggestion is that the LabVIEW development environment is equipped with a functionality where the drivers, add-ons... required for your code can be shown.

There are cases where a variant constant / control needs to have a data value. This can be done by right-clicking a control / constant, selecting Data Operations -> Copy Data, then right-clicking the variant and selecting Data Operations -> Paste Data. This can be time consuming for many variants.

 

variant_drag_1.png

 

The idea is to allow dragging and dropping of a control or constant onto a variant, and have the data copied to the variant:

variant_drag_2.png

Many controls allow you to make scrollbars visible. When a user clicks anywhere within the control, including on the scrollbar, this counts as a Mouse Down. It would be nice if the Mouse Down event would indicate whether the click was on the scrollbar or on the actual clickable area of the control, so you could do different actions based on which it was. Of course, you can usually do manually by checking boundaries of the control against the coordinates of the click, but it seems like a common thing so it would be easier if the check was built in.

Scrollbar Idea.png

We've been saying it for years now.  Enums should be typedefs.

 

Why not make EACH and EVERY dropped Enum into a typedef automatically.  Drop a new Enum from a palette, it is a typedef.  Copy it, it's linked to the original.  For my taste, even ask for a save path after dropping the enum but for the sake of our sanity, just make each and every enum a typedef already.

I feel like in a few cases, my code could be more readable, if a picture ring constant existed.  By that I mean if I could have a block diagram object, that showed an image, and clicking it would allow me to select one of the other images in the ring, which correspond to a numeric value, just like the picture ring control does.

 

I've come into a few cases were I want to know if my picture ring on the front panel is equal to some case.  So I will use the equal primitive and compare my picture ring control value to a constant.  Problem is my constant is just a numeric, because that is what the data type of the picture ring is.  I then usually need to put down a comment explaining what the value of 2 or 3 is supposed to be.  I feel like a better solution for readability would be to have an equal function, and wired to it, is another instance of that picture ring type def, where you can see the image that the value is being compared to.

 

Now sure this doesn't come up often, and in most cases it is recommended you convert that ring into an enum, and then you get a bunch more benefits, but in a few cases I feel like adding a picture ring constant would only make the code more readable.

 

Picture Ring Constant.png

If we run an installer that was built with the application builder, sometimes it can happen that we have the exact same version of the program already installed. Nothing to do! Easy, right?

 

We get a nice dialog telling us that "No software will be installed or removed". So far so good.

 

Any reasonable person would think that we could just press [Next >>] here, proceed with doing nothing, and close the installer without further roadblocks.

 

Unfortunately, the [Next >>] Button is disabled and greyed out . Why??? It seems to be a perfectly valid operation at this point.

 

If we press [Cancel], we get yet another dialog asking us if we are really sure to cancel. Of course we are sure!!! There is nothing useful this installer can do on this particular machine at this time, so get it over with already!!!

 

 

Idea: If the installer determines that there is nothing to do, we should be able to press [Next>>] and close the installer without further dialogs.

 

 

 

 

(I assume that this is not a Microsoft thing cast in stone and that NI can actually do something about it)

 

 

 

The „Search 1D Array“ primitive should have a Boolean output “Found?”

 

 

I was thinking it would be nice to call the DETT programmatically, in particular:

 

1) Start and stop a capture

2) Save and load a configuration

3) Save the log file to a user-defined location

(4) Perhaps even compare log files, although this bit can also be done using existing technology

 

As we get used to more multithreaded programming ideas, such as the actor framework, the DETT will become more important as debugging with independently executing clones is not straightforward. One such really nice feature for the AF has been created by niACS (https://decibel.ni.com/content/docs/DOC-44158).

 

The next step to me now is to allow it to be called, for example, during a unit test, so that I can measure performance. There is clearly a chicken and egg problem, because the code in which I call the event may preload the code under test, but I can easily imagine being able to set up and tear down the test using different VI's.

 

How will this help?

 

1) We can do something correctly, record the trace, save the file and then diff a unit test against the good file, checking that it still produces the same output (if we fire user events as niACS did with the AF). This might not be the best way of unit testing (we ideally develop the test before the code, a la Test Driven Development) but we also should be allowed perhaps to look inside the process (white box testing) to see if more calls are used, say, than the last time the code was run.

2) We can create performance benchmarks for code with tests that are easily re-run. Sure, we ideally should use the same machine with no more software than the last time the test was run, But we can also

 a) See variation across different machines, platforms, etc.

 b) Assess code smells at a quantitative level

 c) Assess upgrades across versions of Labview

In the same way that mouse clicks, key presses etc can be filtered or modified before being accepted, having a Value Change? event option would allow tighter control over input data than possible using the Data Entry tab, and without needing to wire to a Value property node or local variable as AQ suggests here.

 

While this idea in itself probably doesn't make much difference, it would be very useful if such an event could be "bound" to a .ctl (a sort-of mini-XControl) in an enhanced version of what the Data Entry tab currently does.

It would be nice to have a conditional tunnel that can be extend with more tunnel.

In this example, each one has it's own output as 1D-array and only one boolean trigger.

 

 

Multi Conditional Tunnel.png

Right now we can make a conditional disable structure that behaves one way if we the VI is running in the Run-Time engine or not.  What I think would be useful is if we could also decide on performing one case or another based on the version of the Run-Time/Development of LabVIEW.

 

Say I develop some neat little reuse VI that relies on getting the name of the label of data type passed in.  OpenG has a functional already that does this called Get Data Name.  NI has a version as well in vi.lib called GetTypeInfo.vi.  The problem is in 2011 the OpenG method is about 10 times faster, but in the 2013 version the NI version is 10 times faster.

 

Wouldn't it be nice if a conditional disable structure could choose to do one thing over another, based on the version of LabVIEW it was being run in?  This way reuse code could be written to perform best in what ever version it was running in.

 

There are many situations were one code written using some function either runs slower or faster in different versions of LabVIEW and using this we could choose the best option for that environment.

 

Of course there is a work around and that is to read the App.VersionYear property, put that into a case statement and perform different code for one version or another but this has added over head, and is called every time it is needed.

 

EDIT: Also the App.VersionYear can't be used in inlined VIs because it is a property node which a conditional disable can be used.

Hi All,

 

I had posted this same idea in another post but it didn't have enough clarity and was mostly misleading the forum members. I was not able to edit it that I had to post this in a new thread here. 

 

The Idea

I felt that it would be good to have an option to switch to the last visited case in a case structure with numerous cases when going through the cases for debugging or understanding a code. It often happens that I have to scroll through the list of cases to get to a case and then may be I'll have to check something in the top most case. Again if I have to check the last visited case, I have to again scroll all the way down to the case, which becomes a little tedious. Instead, it would have been good if we had some kind of option to switch to the last visited cases sequentially (in a right click menu of the case structure or some keyboard shortcut after selecting the case structure). 

 

I'm sorry if someone has already posted this in the idea exchange forum. I tried to search it but couldn't find any such posts.


Regards,
Nitz

Hi,

 

building a large project consisting of several executables and an installer is no problem when using the AppBuilder API.

But a quite time-consuming task is to open all build specifications to update the build path or the file  versions.

E.g. opening the build specification of an installer containing several executables can take up to a minute even on an up-to-date pc.

 

So I suggest to enhance the AppBuilder API with property/method nodes to manipulate the "often-to-be-changed" properties. An example is attached below.

 

Regards,

 

Bastian

 

AdvancedAPI_lvie.png

When deleting linked tunnels, any wires that are only passthroughs between the terminals (i.e. are not wired to anything not linked to it) should be automatically deleted.  This should work regardless of whether the input terminal or the output terminal is deleted.

 

When multiple output tunnels are linked to the same input tunnel and one is deleted, only the broken portion would be deleted (again unless the wire is connected to something other than another linked tunnel).

 

A use case for this is when you have a bunch of shift register passthroughs in a queued message handler and decide to combine them into a cluster.  An additional benefit of this is that the broken wires that would remain would point out the code that actually used the linked terminals and would thus likely need to be changed (i.e. wired up to bundle/unbundle by name).

 

Linked Input Tunnel Idea.png

Picture says it all, create a new VI from a template within a project item

 

new vi from template.png

 

 

Creating a function palette i noticed how horrible the current system is, why can i not:

- R-click and activate scrollbars

- Resize palette window (i have to programatically change the .mnu file to change palette layout)

- Drag'n'drop functions

- R-click and sort functions (i have to programatically change the .mnu file to change palette layout)

- Insert rows

- Insert columns

- Reedit icons (although i use the new editor it gets flattened so if i want to change the icon afterwards it's an old style flat one)

- Get automatic/linked icons (e.g. say "Use icon from this .class file)

 

I'm sure there are more improvements to be done, but those are from the top of my head.

 

Basically it should be/work like a normal window and a normal array.

 

/Y

Hi,

 

Sometimes I want to wire to a terminal that already has a wire wired to it, while wanting to wire that wire to some other terminal (for instance if I change my mind about the build order of an array).

 

I may want to get from here:

 

InheritWiredWire_Start.png

 

... to here:

 

InheritWiredWire_Final.png

 

The usual way is to;

 

1) Delete the already wired wire, freeing the terminal I want to wire the "9" to.

2) Wire the "9" to that now free terminal

3) Rewire the old wire from whichever wire stub hanging on the BD to its proper terminal.

 

Now we could wait for one of the "general swap terminals" ideas to get implemented, like this one, but I have (IMO) a simpler request (this one might not exclude the others):

 

When I wire something to an already wired terminal my new wire gets wired instead of the old one, and the old wire gets left on my wiring tool ready for wiring somewhere else. I'll try to illustrate it like this:

 

InheritWiredWire_WireOnTop.png

 

When I click the terminal on top of the other wire, I get the old wire on the wiring tool instead:

 

InheritWiredWire_InheritedWire.png

 

... and then I can immediately wire the old wire to its correct location:

 

InheritWiredWire_EasyComplete.png

 

I'm sorry if this has already been suggested somewhere, but I have searched among the many different variants of wiring optimization ideas in this forum and came up with no match.

 

Cheers,

Steen

I didn't see this elsewhere--sorry if its a duplicate. Basically, the old string->number and number->string conversion VIs are capable of accepting arrays. This is pretty great. I like it. However, I also know that it is generally a better idea to use the more fully-featured Scan From String and Format Into String functions. The problem is that these functions do not accept arrays. I know the functions are slightly different, so I wouldn't consider this a bug, but it is definitely a usability feature I would love to have. Picture below. Thanks.

ABCD.jpg

It would be great if LabVIEW supported the Python language, including any of its various packages such as numpy. Such computations would be much more transparent and easier to support than calling code in DLLs. They would also be much more open and flexible than the existing built-in computational solutions in LabVIEW, e.g., expression/formula nodes. Currently, I have to call Python scripts via System Exec.vi, which complicates data exchange. (NOTE: I am using an older version of LabVIEW: 2009 SP1.)