LabVIEW Idea Exchange

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

For modern application development we need better methods to detect wheter our application is called to open a file.

Currently the only help NI gives is based on command line parameters. And we need to jump through loops to get it working to react on opening a file when the program allready runs.

 

This is a major showstopper in creating professional applications.

 

LabVIEW 8.2 had a hidden event for getting this event, which unfortunatly doesn't work in later versions.

 

 

When you or two numeric numbers it does a bitwise or.  The same should happen when using Or Array Elements, but it is not supported for numeric arrays. I see no reason why it shouldn't work just the same?

 

test.PNG

Important disclaimer: I am sorry, this is not my original idea, because it is (together with many other nice features!) already implemented in the LabVIEW UI builder. Credits go to the relevant NI developers.

 

This Idea posted here tries to see how much interest there is in such a feature and to show support that we want this also implemented in plain old LabVIEW. Personally, I really like it! 🙂

 

(It is also somewhat related to this idea (but probably not a true duplicate), especially my comment there already exapands on the idea!)

 

The Unused Items Tray (see also e.g. Christina's Blog entry) is an area on the diagram that contains terminals or FP objects that have not yet been manually placed or are currently only "used" on the BD "xor" FP, i.e. not on both.

 

The current problem in LabVIEW is that if you place a new control on a complicated VI, the terminal will end up on some random place, typically piled well camouflaged on top of some other diagram structures and possible a scroll away from where it is actually needed. Similarly, if we create a control or indicator from a terminal on the diagram, the control will typically be outside the carefully placed visible area and there is no way to grab it without first messing up the FP alignment by either scrolling or enlarging the window.

 

In all these cases, it would be nice if the objects on the "other" window would land in a predictable reserved floating location for quick and easy manual placement where they belong. During development, there are probably a few terminals that are not yet used or connected, and we should be able to place them back into the unused items tray of the diagram so they never scroll out of view or get misplaced.

 

On the front panel, we might have some spare controls "parked", and they would not show in run mode at all. This could even be abused for "local variable zombies" (=hidden controls with the sole purpose of making a local variable) along these lines, which might be OK (=better than hidden controls!). Front panel items in this tray would look like their palette entries. We don't want e.g. full-sized graphs in there!

 

Now, how should all this look like? In order not to cover valuable diagram space, it should be something that collapses to near nothing when not used and would only expand to show the current contents when hovering or clicking in a special area. Of course there should also be an option to pin it open. When minimized, it should look different when "not empty" vs. "empty".

 

I would like to be able to create BD array constants from the predefined string and numeric constants.

 

Presently you cannot create an array constant by dropping a predefined constant into an empty array box on the BD.  Arrays of string constants such as Carriage Return, Line Feed, Tab, and Space need to be created programmatically using build array or manually using the '\' codes or hex codes.  Arrays created in such a manner do not have the graphical indications of what is contained.  Some of the constants (Space) are actually VIs, which may complicate things for NI.

 

Similarly the Math and Science constants like pi and e should be allowed to be dragged to an array of DBL.

 

Lynn

Arrays from constants.png

 

 

I got some code from a coworker that I'm building into an EXE.  There are a lot of references to user.lib (like 60 classes) and the folder structure that my coworker gave me makes some of the classes in user.lib too long and causes the exe to fail building.

 

I moved the stuff from user.lib to a root folder on my C drive and now I have to manually update every class because they aren't in user.lib.  Its pretty time consuming and I think just saying "Look in this directory for the missing files" would help tremendously for larger projects that need to get moved around.

By default, VI Server uses TCP to communicate between applications.  This stream of data is not encrypted and open to hacking and snooping.  

 

My suggestion is allow VI Server traffic to be encrypted, perhaps using SSL/TLS  or an AES algorithm.

 

The reasons are obvious.  There is an increasing number of cyber attacks in industrial control systems.  Many cyber attacks are perpetrated internally, so a firewall or air gap is only so helpful.  And in certain environments (ie military, medical) you can't even consider transmitting data without encryption.  This means VI Server is not an option for many users.

 

I see that LV2020 now supports SSL/TLS in its TCP functions (see here), so the logical next step would be to make use of this in VI Server also.

One of the annoyance of designing a UI is that you will never know for sure how it will look on another user computer.

 

For instance, you design your UI with the default 13 point font size and when a user that has it default font size set to say 16 (and with a different font type) open your UI everything is a mess (text run out of the screen, text overlay controls ...).

 

In built application (meaning in an exe) one can add the following line to the executable and this fix the problem by coercing the font type and size.

 

  • AppFont=""Tahoma" 13"
  • DialogFont="Tahoma" 13
  • SystemFont="Tahoma" 13
  • CurrentFont="Tahoma" 13

 

But what about a reusable tool that are basically a source code distribution?

 

Currently, the simplest way to ensure this outcome is to write a reusable VI that will recursively set the font size and type of every labels or string to be what you designed your UI to use. This VI has to be run by the UI every time it starts.

 

What I propose is to add a global VI settings (probably somewhere in the VI properties) that will persist whatever font settings was used to design the UI.

 

Persistent font settings.png

 

This setting should default to false.

 

The image above is one possible solution (the simplest one).

 

Another solution would be to explicitely defined what every font style&size should be for every font type (something very similar to the explicit definition one can use in an ini that I mentioned above). In that case, there could be an entirely new font category in the VI properties.

 

Persistent font settings 2.png

 

PJM

For the "VI Documentation" test, it would be great to have an option to skip controls (.ctl). We never add VI Documentation to typedefs or other controls. 

 

vi-documentation-skip-ctls.png

 

(cross-posted to VI Analyzer Enthusiasts)

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.

The ability to shrink cluster constants on the block diagram is awesome and works really well, however when they are a typedef they appear as a large icon and not the small cluster I have come to love.

Make it so that the typedef glyph works with the shrunken cluster properly.

Better Cluster - Old Cluster

Best Cluster - cluster idea2.png

LabVIEW's Query Input Devices uses LVInput.dll to return information about the Keyboard(s), Mouse(s), and Joystick(s).  However, it appears that the number of Joystick entries returned is limited to 8, whereas on several machines that I've examined, the "joystick" device can be present in slot 10 (as noted by DxDiag's Input test, which otherwise matches what LabVIEW returns in the first 8 slots).

 

Can this function, which returns an Array, be modified to return as many entries as the DxDiag utility returns for DirectInput?  This would facilitate using multiple joystick-like devices as control units using standard LabVIEW procedures.

 

Bob Schor

Currently I have to put

 

"allowmultipleinstances = TRUE"

 

into the ini file manually.

It's great that you've put connector pane and VI icon side by side in the Front Panel

It's more useful if you can put the same in the Block Diagram

Untitled.png

A picture is worth a thousand words.

 

Listbox Control.png

 

Basically I'd like more control over the text in listboxes.  I want the same level of control that you can get from a string control, where each character in a string element can have custom font settings.  At the moment each line in a listbox must have the same settings.  This idea is to have more control over the font settings of listboxes, and multicolumn listboxes, as well as implementing the property nodes that allows for these settings to be controlled problematically.

LabVIEW currently porvides TCP and UDP primatives. It would be nice if it had a PING primative as well.

There are a plethora of timestamp formats used by various operating systems and applications. The 1588 internet time protocol itself lists several. Windows is different from various flavors of Linux, and Excel is very different from about all of them. Then there are the details of daylight savings time, leap years, etc. LabVIEW contains all the tools to convert from one of these formats to another, but getting it right can be difficult. I propose a simple primitive to do this conversion. It would need to be polymorphic to handle the different data types that timestamps can take. This should only handle numeric data types, such as the numeric Excel timestamp (a double) or a Linux timestamp (an integer). Text-based timestamps are already handled fairly well. Inputs would be timestamp, input format type, output format type, and error. Outputs would be resultant format and error.

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.

 

Allow tables, list boxes, etc to be able to lock the right hand column. Currently if you resize a table or list box (or any control/indicator with columns) you end up seeing more columns. It would be nice to be able to lock the right coumn so no additional columns are displayed. Most instances of tables have a defined set of columns which will be used and it looks rather ugly to resize and end up with empty columns. The current alternative is to have code running that will do this programmatically which is a bit cumbersome. Effectively this is allowing the programmer to set a maximum number of columns.

When a cluster contains refs to different type of controls that have a common ancester, the "cluster top array" primitive should be able to handle it instead of having a broken wire.

 

Example_VI_BD.png

 

Indeed, if the lower snippet works, one can assume that it shouldn't be too hard to get the upper one to work as well when possible.