LabVIEW Idea Exchange

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

Given the properties dialog box isn't resizable, and there's nothing under the table (apart from one tick box), could you make the items table longer? It's really annoying when there are a few extra values that can't be seen because the table is too small.

 

Proposal to make the Edit Items box longerProposal to make the Edit Items box longer

 

I often make small For Loops using Auto-Indexing, and only occasionally do I use either the Iteration Terminal or Count Terminal. My current practice is to tuck the Iteration Terminal under the Count Terminal just to get it out of the way, shown below. I propose that these two terminals can be shown or hidden (circled in green), just like the Conditional Terminal.

 

CurrentForLoop.png

 

Here's an example of the new lower-profile For Loop with the unnecessary terminals hidden:

 

LowProfileForLoop.png

Similar to Visible items>Radix right-click menu it would be highly beneficial to have the same possibility for showing (and switching) of Representation.

 

 

ice_video_20200504-153122.gif

I use the conditional disable structure in my projects to turn debug options on and off.

At the moment before every build I have to go into the project properties and make sure that DEBUG variable is set to FALSE and after the build I have to change it back.

You can get around this by automating you build but an option in the build specifications would simplify this.

 

It would make life much more convenient if there were a list of the available (non-system) conditional disable symbols in the application builder dialog where the appropriate variables for the build could be set. This would also allow for a simple duplication of a build spec to have one with DEBUG=TRUE, and one with DEBUG=FALSE.

When debugging (and at many other times), I want to copy data from a probe or control into a text file, Excel, whatever.

 

For reasons that I am totally unable to fathom, it copies the control as a bitmap. Print screen provides this functionality already. I think copy data should copy text instead!

 

copy_data.png

 

I wasn't able to find this on the exchange, sorry if I missed it!

Current Situation

The current commenting practice in the BD is to place free floating comment number labels and write the comment in a text field as in the example below.

Current Code Commenting Practice.png

 

Disadvantages

- comment number labels do to stick to the code block. if the code number block is moved the comment has to be moved as well.

- no link between number and comment text block

 

This unsophisticated way of commenting LabView code lead to the lack of comments in general. Usually a new programmer can understand what happens, but not why a function is implemented like this.

 

 

Proposal

LabView provides the Advanced Code Commenting Functions.


InsertCommentBlock.png

 

CommentBlock.png

 

The comment block is more then just a text block. Basically it has a comment ID, the comment itself and a comment category.

By the context menu the following functions are provide:

  1. add comment
  2. delete comment
  3. move comment up
        The particular comment line is moved up in the comment block. The ID is decremented
  4. move comment down
         Opposite from 3.
  5. highlight function
         The function to which the comment ID sticks is highlighted.
  6. the comment category can be selected. (e.g.. Code Explanation, To Do, )

Adding Comments

Adding a comment in the comment block incorporates two steps (after selecting Add Comment from the context menu):

1. Sticking the automatically generated comment ID to a particular code block just by selecting the item the comment belongs to.

   This could be any type of code: wires, SubVIs, the whole Case, a particular Case, Sequences....

2. Writing the comment

 

 

 

Example of Block 1.png

 

If the mouse pointer is set over a comment ID the comment is shown like a tool tip and disappears as soon as the mouse is moved away.

 

Case.png

 

Advantages

  • Comment moves with function block if function is moved on the BD
  • Comment ID sticked on the BD item and ID on the comment block always match
  • generally more comments in a LabView programm through more simple way of commenting code

 

 

If you have an event that contains a cluster typedef, then the event structure automatically unbundles the data:_carl_0-1633037893996.png

I generally want to work with the entire typdef though. Why not expose the entire typdef to improve code maintainability?

 

(No one wants to re-bundle that data just to send it to a subVI or new event...and then risk losing data when a new property is added later.  Workarounds include adding a typdef of a typdef, or going class-based...but that overhead/creativity shouldn't be necessary.)

 

Problem: Currently it is impossible to know in advance what errors (what error codes) a node or native VI can produce. (Native VI = VI that ships with LabVIEW)

 

For example, I recently implemented a module that communicates with another endpoint using the LabVIEW TCP primitives we know and love: TCP Open Connection, TCP Read, TCP Write, TCP Close Connection. In order to create robust software I needed to understand what error codes each of these primitives can generate, and in what circumstances.

 

Through initial testing I discovered that TCP Open Connection can generate errors 56, 62, and 66. I then handled these errors locally in the code.

 

Around two weeks later, during further testing of what I thought was a fully complete and tested module, the module unexpectedly started experiencing error 60 many times per second. The module had never experienced error 60 before. The module was configured to broadcast an event each time an error was detected. This flooded the listener (the DQMH tester VI that was listening to all broadcast events) with thousands of error messages per second. The tester VI front panel buttons became unresponsive, because the tester was flooded with so many incoming broadcasts. The only way to break out of the cycle was to abort the tester, then close the project to shutdown the module.

 

This way I learned "the hard way" that that TCP Open Connection can generate error 60 in certain circumstances, in addition to the error codes I had handled already.

 

Solution: The detailed help of each node and each native VI should list all error codes that can be produced by that node or VI. For example, in the case of TCP Open Connection, the detailed help should contain a description similar to the below.

"

TCP Open Connection can generate the following errors:

  • Error 56
  • Error 60
  • Error 62
  • Error 66
  • and so on listing here any/all error codes that can be generated by the node.

"

 

This list would be extremely useful, as it would make us (professional LabVIEW programmers) aware of the various error codes a node or VI could occur generate. This would encourage the programmer to think of ways to handle all those possible errors, thus resulting in more robust code.

 

By reading the "Explain Error..." message of each error code the programmer could also understand the circumstances in which the node or VI generates each particular error.

 

Notes

  • In summary, this idea suggests an improvement to the detailed help documentation of each node and native VI.
  • It should be possible to automate the creation of the lists for each node and native VI.
    • For nodes whose source code is written in C++, a program could be created to scan the source code files and return the list of possible error codes generated by the function.
    • For native VIs, VI scripting could be used to achieve a similar purpose and output the list of errors that could be generated by that VI.

My idea is simple: Put the connector pane on the front panel next to the VI icon.

 

Why: Right clicking to show the conpane means extra clicks that would not be necessary if it was always there.  It would also be solve the problem of saving the VI with the connector pane hiding the VI icon.

 


 before_alwaysshowconpane.pngafter_alwaysshowconpane.png

If you copy a group of controls/indicators from a front panel to another, the layout of their terminals on the block diagram is not maintained (instead it is typically messy...)

Vice versa: If you copy terminals from a block diagram to block diagram the block diagram remains the same, but the control layout is messed up.

 

Why not just keep both as they were when copying?

 

 

Bonus-idea: If you try to fix this by using the diagram clean-up function controls with the same name, but an iterative suffix (which the IDE is able to automatically generate itself as well, so it has a relation to it alread) the clean-up ignores the order of the names when ordering the controls...(so it might stack them nicely, but then control ...<n+1> is not put after/below ...<n> e.g. Perhaps it could be a bit more intelligent and include that in the ordering algorithm too?

Once in a while I encounter a case or event list that forces me to grow the structure

- in order to keep the list readable:

Selector.png

It would be nice if the item-list would automatically "wrap" instead.  

Selector4.png

When creating a subVI from a selection, LabVIEW should do two things:

  1. Use the user's default connector pane pattern instead of selecting one matching the number of inputs and outputs. This will make easier wiring and allow users to add more IO later.
  2. If the user is using a "standard" pattern (e.g. 4-2-2-4), LabVIEW should try placing the error clusters at the bottom corners and objects or references at the top corners.

It should also try to make the FP of the subVI cleaner, but that's another matter.

It could be nice to have a context help on coercion dots to see what is the expected type of the data that is supposed to be wired to. This way you can rapidly determine what kind of conversion to use to avoid the coercion dots.

 

ContextCoercionDots.png

 

The idea is quite simple to implement, I suppose.

 

Dimensions-tipstrip.png

 

 

 

 

 

 

Two main benefits:

 

1. allows you to know the exact size in pixels that the front panel will get at runtime, while the manual resizing of the FP occurs.
This feature should take in account VI's Windows Appearance options (Window has title bar, Show toolbar when running, ... etc). It helps you to set the FP size for the (different) screen on wich the program has to be run.

2. this feature can help you to set the BD size for the smaller screen on wich you know you'll have to edit the program.

Up to now you can only set a minimum FP size, and use it as a sort of "pixel size reference". However this is the internal net size of the panel, toolbars and title bar excluded, and the final setting is a bit tricky. You can also programmatically change the FP size, but this is of little use, if you don't want to risk that some control disappear out of the panel boundary.


The second benefit is only for those of you that use LV on different PC (Lab and laptop, for instance) like me...  and, like me, hate having to scroll the BD for editing it :-). Usually I set the BD size to the maximum possible dimensions of the smallest screen I use.

 

 

Cheers

When I Control+Right click and drag to expand a block diagram. The expansion should NOT effect all of the unseen case frames

 

I am really tired of stuff like this happening when I expand the diagram of another frame of the same case horizontally and vertically.

 

This "Short cut" actually creates a lot more work for me as now I have to go back and clean up all the other states in my state machine that are messy now.

 

CaseCapture.PNG

 

There seem to me to be a couple of choke points in right-click access to VIs and functions.  One is that I frequently need to use the same VI's repeatedly.  Another is that the quite useful "insert" and "replace" context items only offer a few first-tier options: one or two related palettes, or all palettes.  Try to insert a few datalog functions for example, and you have to navigate down 6 levels for each. It's even worse if you have to use "select a VI..." and browse to it. For the worst cases, insert and replace lose their advantage over copy-paste or quick drop.

 

 I propose a dynamically generated palette consisting of the last several VIs and functions (even controls) that have been dropped.  This is analogous to recent-commands-list functionalities common in CAD packages.

 

- As a member of the functions palette, the items in it are at or above the level they are in their normal place in the hierarchy.

- Since it's a palette you could pin it and it would be handy for dropping the same node on two different block diagrams

 

 

recentVIs1.png

recent_replace.png

When you connect the error wire to a case structure selector, you get two cases for error and no error. I think you should be able to add in cases for specific error numbers so you can handle specific errors differently. You could do this currently, but you would have to unbundle the error and use the error code.

 

Numbered error case.png

Support unicode officially for all FP indicators and controls! Captions and string indicators can be "coaxed" into showing Unicode characters (among other controls/indicators), but trees and listboxes (among most others) cannot show Unicode.

 

Of course, this may have a small audience, but anyone who has developed a UI meant to be distributed to half a dozen language-speakers has probably fought the same Unicode battles and figured out the display "hacks" that we have.

 

Unicode!.png

This is a really basic thing, but it would be helpful if the qualified name (as seen in VI Properties) was enabled so it could be copy and pasted into documentation.

 

When I'm writing detailed documentation to tell other developers how the software works I often use the qualified name as opposed to VI name. For example "Send Creep Command.vi" doesn't tell the developer where to find it, but "Motion Control UI.lvlib:Motion Card 2 Data.lvclass:Send Creep Command.vi" does.

 

McQuillan_0-1642064820004.png

 

I would be happy with the string being enabled (so it can be selected and copied), or a button that copies the string into clipboard.

 

(Inspired by this discussion)

 

The Index & Bundle Cluster Array function currently discards any labels of the input data. I think it would be more useful if it would try to retain the names (i.e. copy the original array labels (if available) to the element labels of the output).

 

The picture illustrates the idea. On the left we see the current behavior and on the right what we would get after this idea is implemented.