LabVIEW Idea Exchange

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

Make the Panel Resize event in the event structure a filter event.  This would allow for clean, professional looking control of VI panel size.  Use cases include: limiting the maximum panel size, preventing a panel from resizing in one direction, only allowing the panel to resize in discrete increments, etc.

 

In traditional windows programming, filtering the WM_RESIZE event is often used to control window size and I'd like to see this same functionality come to LabVIEW.

 

Ideally, this change would include a Discard? option as well as NewBnds and Act as options in the Event Filter Node.  Setting NewBnds or Act would allow the programmer to amend the resize before it takes effect.

 

Panel Resize Filter Event Idea.png

Originally discussed here, this would be a time saver in quite a  few cases:

 

when dropping a structure (sequence, case, while or for loop, etc) over wires, an option should be provided allowing these wires to go through the structure (instead of ending up untouched UNDER the structure as is currently the case). Maybe with a modifier key?

 

Illustration:

 

Starting from this simple situation, where I want to do some comparison on the two strings (please imagine that the wires go through a lot of hooplahoops rather than directly to the indicators shown, as otherwise the solution is trivial):

 

ScreenHunter_001.jpg

 

I currently need to drop a sequence structure and do all the connection manually before creating a subVI (or doing stuff in a case structure, see below):

 

ScreenHunter_002.jpg

 

The suggestion is to go directly to this:

 

ScreenHunter_003.jpg

 

The reasons this would be useful are plenty, I think.

For instance, you want to do some sanity check on a bunch of wires now that you have added a new control on your panel. As of today, you need to drop a case structure, get wires you are interested in one at a time, connect them to the left of the structure, pass through the structure, connect them to the right of the structure, delete the wire underneath the structure, reconnect them to the right tunnels, etc...

Now, for a case structure, there might be some options on how to do that (for instance connect the wires through all cases? through the True case only?). Likewise for a while/for loop (you could autoindex at the entrance and/or at the exit, a mess that already exists anyhow).

 

My 2 cts.

I frequently perform operations on Maps of Objects which hold private data where I do not intend to alter the structure of the Map.

Existing Solution

However, Maps are a bit clunky to work with when operating on all Elements. You must first get the list of all Keys, then use an In Place Element Structure within a For Loop and Shift Registers to operate on each Element as follows:

Map In Place Element.pngPotential issues with this:

  1. Unnecessary branch of the Map which may not be optimized by the compiler
  2. Excessive block diagram editing which slows down the development time involved when working with Maps
  3. Potential for syntactical errors due to complexity of this operation

Proposed Solution

It would be great if there were some kind of auto-associating tunnel available to For Loops:

 

For Each Element in Map.pngNote that the Key is not modifiable, nor is it even available within the For Loop.

 

 

Perhaps the tunnel icons must be changed so they are not confused with shift registers.  I just copied the association icon from the map datatype icons.

 

 

 

 

This level of functionality is similar to the syntactical abbreviations available in most languages which support maps as a standard data type.  I originally wanted this kind of functionality for Sets as well, however modifying the values may result in structural changes to the set itself due to the uniqueness constraint.  As such, this is only applicable to Map Values within For Loops.

 

It may not be obvious, but this kind of tunnel would not be available to While loops.

Selection

AutoAssociation Context Menu.pngThis option would be available on the block diagram through the context menu items of the Map datatype Input Tunnel to the For Loop.

 

 

 

 

 

 

 

 

 

 

 

 

 

Problem: my code accesses many different properties of many different controls. I need to locate where a specific property of a particular control is read/changed.

 

idea.png

 

I know that the Find panel offersi me the option of searching by text, like

 

Screenshot from 2015-02-01 13:46:10.png

but that is not the solution, because I need to type thename of the property, and because I may match many other objects with the same string (comments, other controls with the same property, etc.)

I'd like a faster way to get to where I need. For instance the contetual menu could offer Find/specific property according to where the right-click was.

I did a search for explain error - I did find this idea which is similar but for probes.

 

Explain Error is a feature I have been using more lately but its not available for an error that is in an array (LabVIEW 2010).

It would be great if it was!

 

Cheers

-JG

 

 

Explain Error In Error Array.png

Could it be possible for LabVIEW (even if only for versions 202{1,2,3} onwards etc) to make an attempt to open newer files and just break them when new features are used?

 

The comments in this Idea (LabVIEW Compatibility Modes) suggest this and related ideas, but it isn't the main part of that idea, so I'm posting it separately here.

 

An ideal solution for me would be for VIs to automatically save back in the 'oldest' version that they would support (and perhaps not be 'up-compiled' on load), but this idea has been discussed a few times and doesn't appear to be something NI will support.

 

An alternative (perhaps only possible in currently unreleased versions?) might be to have LabVIEW 202x try and open a VI saved in 202<x+n>, and then give the symbol for missing VIs (ideally with the name, if possible) for anything that isn't supported.

 

As an example, trying to open a VI using Insert into Map (if this were available for existing LabVIEW versions) in LabVIEW 2018 could produce something like

cbutcher_0-1596430804139.png

with the Context Help giving me a clue as to what was lost - I could then Google "Insert into Map LabVIEW" and try guess how I might replace it (here, probably with Variant Attributes).

 

I'm posting this idea in relation to some comments I've recently heard regarding sharing and packaging code with LabVIEW, and how even when other (text) languages add new features and so code using them will fail to compile, their users/developers can still open the code, try fix bits, or generally workaround issues (and evaluate the benefits of upgrading, if the changes are large).

New versions of LabVIEW continue to have significant new features, so upgrading seems like it will continue to be at least my preference, but not everyone has the same requirements/situation/SSP/blah blah blah.

An addition to the 'Find' project provider (or a standalone one) to find Parent Interfaces would be good.

 

I expected it to be included in LabVIEW already, but I don't see it.

Parent Interface Ideas.png

 

 

Say I've got 4 U8s that I want to join into a U32 - right now, I have to build 2 of the U8s into a U16, then build the other U8s into a U16, then build the 2 U16s into a U32.  I'd like to see these primatives growable to each datatype width.

Add a module to LabVIEW to use it on Android OS or Apple iOS. 

 

People have already been getting smartphones for awhile.  And now in 2011, there are so many manufacturers that make tablets with Android OS or even Windows.  Apple iOS is considered to be the cool thing but Android OS is more open and used by more manufacturers (since only Apple for it's iOS).  Since the Andorid Tablet is so new, yes there are more Apple tablets out there than Android tablets but if it's like the smartphone market, Android OS will overtake the iOS market.  It's just a matter of time. 

 

I don't know whether one is easier to code than another, but if you had the time I think a module for both the Android OS and the Apple iOS would be extremely powerful.  Wouldn't it be great if we could run an instrument from our phones or tablets?!?! 

 

But I would just be careful to make sure the module was robust and not too many key features were missing from the full LabVIEW version.  In the past, we tried the PDA Module and Touch Panel Module for an instrument and it didn't work out.  The module was very buggy and missing a lot of features from LabVIEW that we though were important key ones.  We ended up abandoning the PDA module idea and went with an advantech touch panel computer with Windows XP and just kept writing with regular LabVIEW.

Format Into String can become very complicated when you have multiple inputs. I think implementing it in a way similar to the Formula Node could make it much better.

Ideally,

  1. naming of the inputs should be allowed
  2. the input fields in the string should be color highlighted
  3. when hovering or clicking over any of the input or the format string fields, the matching ones should be highlighted in bold or with different background for example.

FJR0_0-1697721252785.png

As a side note, the Formula Node itself could also benefit from the same color and hover highlighting.

 

I like the "new" Review and Update Typedef feature.

 

What I don't like is handling the CASE structures I have connected to enums when the enums update. The constants for the enums update fine, but the selectors for the CASE structure are not included in this operation.  I really wish these could be handled as pseudo-constants for enums, allowing re-assignment of cases with a preview of old and new values.  I've started adding an enum constant to each case just to serve as a reminder which case it's actually supposed to be. And that feels kludgy.

 

Currently, case structures auto-adapt to enum indices. I'd like that to no longer be the case.

In LabVIEW we can specify <topvi> as a VI search path when VIs can't be found.

 

I would propose adding <project> as an option (perhaps with a subfolder by default). This would allow for new reuse patterns based on keeping libraries in the project. I expect this would make tools like GPM much easier to develop as well.

 

It could be a first step to something like node_modules in NPM or virtual environments in Python.

 

James_McN_0-1590488521270.png

 

I have seen some ideas relating to Replacing VIs, but I haven't found this exact one...

 

When I think of replacing, I think of the top use cases. One of the ideas I saw related to the class of a VI, that's a common use case. Other Ideas related to performing repeated replaces. That's another common one. And another common use case is replacing with a VI from the project that is not on the template.

 

My idea is to group all of the common use cases on the top-level flyout. IMO, Select a VI... should be the #1 item, then come the palettes and Class VIs (not pictured) and finally a list of the last N VIs that were selected for replacement.

 

I think that this would make a lot of our lives easier.

 

 

NOW:

Bad.jpg

 

BETTER:

Good.jpg

When programming in FPGA, all the timing functions are polymorphic, meaning you have to configure it for either ticks, us or ms. If your not carefull, this can sometimes lead to unwanted error due to simply overlooking a wrong configuration, as in the following example picture:

 

How are the timing functions configured?

 

I propose a simple indicator or different icon to easily see the difference. Something like this, only maybe better looking:

Proposed solution

This idea started when I realized the WebDAV API provided by NI does not have the ability to read the File Creation information on a remote file.

 

Example_VI_BD.png

 

"That's okay" I thought, I'm a programmer and will add it myself.  Looking at the source it looks like NI just leveraged someone else's protocol, and wrapped it into some Call Library Function Nodes.  NI could have written the WebDAV API wrapping their own HTTP API functions, using G instead, allowing for customization but they didn't.

 

"That's okay" I thought, I'm a programmer, and I'll look into recreating the WebDAV API, by calling the NI HTTP API.  Looking at the source sounds like NI didn't implement all of the HTTP functions available, only the most basic ones.  And since WebDAV requires more than just the PUT, GET, and POST, that means also having to update the HTTP API to have those functions, so that I can rewrite the WebDAV API.  Oh but look at that, NI also just (seemingly) wrapped someone else's implementation again into Call Library Function Nodes, this time calling the ni_httpClient.dll.  NI could have written the HTTP API wrapping their own TCP primitive API functions using G instead, allowing for customization but they didn't.

 

So this idea is for one or more of the following things, from the easiest, to the most difficult.

 

  1. Add the File Creation Date, as returned information from the Get File Info of the WebDAV API.
  2. Implement the WebDAV API in G, and eat your own dog food.
  3. Implement the HTTP API in G, and eat your own dog food.

StringConstant1.png

As everybody knows there are two ways for generating an empty string constant in the block diagram: Using the "empty-string"-constant or creating a genereal string constant with no content.

 

Both ways have advantages and disadvantages:

- The "empty-string"-constant shows much better that the string is empty but it can't be used e.g. in arrays.

- The string-constant can always be used, it is easily generated by right-klick to a string terminal and selecting "create -> constant". Furthermore its value can be changed to somthing non-empty if required. Disadvantage: It's hard to see if the constant contains nothing or just a blank sign.

stringConstant2.png

 

My suggestion: LabVIEW shall show a string constant which contains an empty string always with the symbol that is currently used for the "empty string"-constant. This is also valid if the empty string is within an array or cluster. If this behaviour is not wanted in a particular case, there shall be the conext-menu-option "show symbol for empty string" which could be deactivated.

stringConstant3.png

 

For changing the value of such a new string constant, the symbol shall change to a classic string constant if the user moves the mouse (with selected text-editing-tool) over it.

Similar behaviour is also suggested for general-path- / empty-path-constants.

 

Remark: I'm working with LV2015SP1

The title say it all.

 

The Build and Strip Path primitive should be able to operate on array of path and array of string.

 

Polymorphic Strip and Build Path.png

 

PJM

We can right-click a string object and change the state (control, indicator, constant, array, element) by right-clicking. Unfortunately, the current behavior is (partially) inconsistent in the way the display format (normal, /-codes, pass, hex) is handled. Here are some results (list is incomplete), the symbol <> means in either direction.

 

Control<>indicator: The display format is retained

Array<>array constant: The display format is reset to "normal". *(Also see below)

Control|indicator<>constant: The display format is reset to "normal".

 

(*note that if I drop a string constant into an empty array container, the format and element size is retained. Converting to array using right-click should do the same!)

 

Whenever a conversion involves a diagram constant, the current display format is lost. I think it should be retained!

 

How about this for a possible improvement.

 

It would be neat if there was a format painter button somewhere on the toolbar that acts like the format painter in a word processor, this format painter would copy all formatting information from one object (probably a FP control/indicator) to another.

 

Click on the first object, click on format painter and then click on the second item and viola! the formatting is copied over.

 

An example of this is setting the numeric format (which takes quite a few clicks to set the significant digits etc). I know its possible to edit properties of multiple similar objects, but this is a bit different.

 

Maybe this would work on the BD as well?

 

I think it would probably be possible to do this with JKI's Right Click Framework, looping over all the properties of and setting the destination the same as the target.

V1.0 of TOML was recently released : https://github.com/toml-lang/toml/wiki

There is an MIT Licensed open source project here : https://github.com/erdosmiller/lv-toml

 

It's a nice starting point, but :

- it's not complete

- it's based of v0.4 of TOML

- it not maintained as stated here : https://lavag.org/topic/21972-anyone-using-toml-files/?do=findComment&comment=135193

- it's not native