LabVIEW Idea Exchange

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

Many times, at least in my codes, it's necessary to act only on a rising / falling or changed edge of a boolean signal.

Probably this option can be added for CASE-structures with a boolean-type case selector of cause. 

It would be better if we could probe the auto indexed tunnel while the for loop is still executing.

 

If the For Loop is running for a huge number of iterations and if the Auto-indexed tunnel is having a condition. Then to check the values in the conditional auto-indexed array should be made possible even when the for loop is still running for debugging purpose.

 

If something like the below can be done it will be helpful in debugging.

For Loop Tunnel Probe.png

Hi

While working with LabVIEW I would suggest that there are broken arrow that shows that the code is not complete if we left to wire any input or output.

I would suggest that there should be an option in the block diagram that we can select the active region (it could be as to draw box) and LabVIEW should only consider code that is inside the box and outside of the box if any unwired input  or output should be ignored.

 

I hope  I made my idea clear.

 

Thanks

Asif 

It would be useful to add a Boolean for resetting "First call?". Sometimes it might be required to reset a first call during a run.   
It could be as following:

KhalilEslami_0-1684738034968.png

 

Many of these VI properties are "Run-time" writeable.  They should not be set while the vi is in an "Idle" state 

 

Screenshot 2023-05-12 191049.png

LabVIEW crashes randomly when network functions are used on Linux. This problem appears especially when many connections or files are open.

R&D has identified the issue but is evaluating wheter or not the issue will be resolved in future releases.

 

All the details are here : 

https://forums.ni.com/t5/LabVIEW/TCP-Allow-files-descriptors-gt-1024/m-p/4297433#M1255356

 

An example is attached.

 

 

 

 

Download All

It would be nice to easily find objects that prevent a structure with "Auto Grow" from becoming smaller in size.  For example, the Add function in  the True case in the simplified example below.

 

NIExpert_0-1680056795428.png

 

 

I have a large base of compiled executables. One computer is encountering a "not enough memory to complete this operation" error. I'd like to drop a debug version of the executable on their computer and see if I can monitor which VI is using all the memory similar to DETT's remote monitor abilities.

 

New profile tool2.png

Sometimes, when debugging code, I may force a situation, e.g. force a boolean to be TRUE or FALSE, or force a For Loop to only run once. Once I have made the fix I then forget to reverse my changes and run my code. Or, even worse, create an executable and send it to a customer. Doh!

 

Could we create a primitive, in the shape of a small bug, that I could drop in my code at the point where I force the code? Then, when I come to run a popup asks "Run with bug?" This would allow me to debug my code, but would also remind me to undo the deliberate bug before I run the code for real or try to create an executable.

I think LabVIEW should have something like the dialog VIs that acts as a popup where the vi displays a message to the user but doesn't hang up code and wait on the user to press a button.

 

An example case is a state machine that has error checking built in errors out.  Instead of creating a more complex error handling scheme to display the state machine errored out and heres why then shutdown the state machine, you could instead drop this async popup in the state with the message to display the error occurred then have the state machine shutdown like normal.  This way, the user knows "the state machine shutdown for X reason" while the state machine also goes into a safe state.  

 

I think the async popup is easier to trace since the error message is located in that section that detected the error vs having some sort of store an error string then in the shut down case read if there is an error and if so display the error once the station is already shutdown.  Additionally, you cold see where all asnyc message blocks are via dropping one in your code then right clicking and searching for all instances.  This could streamline the process to see where the fault occurred since the async message block would be in the location of the fault itself.

 

I have currently built something like this that is a reentrant VI whose input is a string and a secondary VI that launches the display message VI.  It's a bit of a work around, but I can display a message to the user while my code continues to do whatever it needs to.  

The Swap Values node only supports a Boolean input on the '?' terminal.

swap-values-error-cluster.png

It should also support an error cluster input, in the same way as the Select node (pictured) and many other nodes with Boolean inputs.

When a TLS Configuration Refnum is wired to "Not a Number/Path/Refnum" it always returns true, even though the TLS Configuration Refnum has been correctly created and is valid.

 

tls-refnum.png

The idea is for "Not a Number/Path/Refnum" to handle the TLS Configuration Refnum and return false when the refnum is valid.

 

Hello LabVIEW Experts.

 

I am using LV 2017 (Not sure how it works in Recent Versions of LabVIEW). Sorry if its fixed in Recent versions.

Started this thread to share my recent learning/bug.

 

It all started like this.

 

One my Engineer was re-architecturing existing LabVIEW Application and it has 40+ States/Cases Defined- Out of which two were identical and he is not able to figure out the duplicate.

We spend sometime to resolve by sorting and finding the duplicate.

 

Later i was working on the same to figure out why cant LabVIEW Highlight the issue/restrict from adding.

 

LabVIEW does restricts User from adding identical Items when using Edit Items of Enum Properties.

 

PalanivelThiruvenkadam_0-1664173360124.png

But it allows me to add identical items when users adds using shortcut/add items.

 

During this experiment i also found that LabVIEW doesn't allow user to create (Make Type Def) if the items are identical.

The above behavior is perfect but there should be a warning why they are not able to (Make Type Def)

 

I have Few Points on this.

 

1. There should be Error Warning/Highlight  to make user to debugg where the identical cases located (helpful when more states are mapped)

2.There should the restriction in adding items at all levels (all possible options to add items)

3.There should be an warning why user cannot (Make Type Def) when there are identical items.

Hello NI,

I am thinking of a feature that if I hold a certain key such as CTRL and then move a vi that has error in/out wire in it, it will automatically snap to the error line that gets close to it such that the feature will automatically connect the moved vi in between the error wire it is closed to. This will cut the error line and insert the error in and out of the vi that gets close to it. Thus a person will not need to do the following steps:

1) click to error line, then click to input of the error wire of the vi.
2) click to error line again, then click to output of the error wire of the vi..
3) click the unwanted wire/broken path and delete.

Regards,
Mark J.

If you build a PPL with a class and then probe the class wire, all you get is the name of the class, whereas probing a source class shows you its private data.

 

Currently the only way I'm aware of (hopefully I'm just ignorant on this matter) to see the private data is to create extra code to expose it in some form.  This also often requires the PPL in question to be rebuilt which can be a huge pain when trying to debug. If the PPL is built with debugging enabled, wouldn't it make sense to show the private data contents in probes?

In vi.lib\Utility\file.llb the 'file open+.vi' throws an error when a file can't be opened. It doesn't tell which file it can't open.

 

One of the strenghts of LV is the source string in the error cluster that can be used to include a lot of extra information. For example which file couldn't be opened.

 

The change can be very simple, just add the file into the source string, also see attached file:

beuvink_0-1652104974240.png

This is probably true for some other files here as well.

 

(also checking out these files... would be nice if they are updated to some newer standards... still some very old styling here...)

 

Some background: https://forums.ni.com/t5/LabVIEW/Looking-for-feedback-on-the-Carya-PDF-toolkit/m-p/4229342#M1228046

 

 

 

 

 

Support the loading and use of dotnet core libraries.  They are cross platform and could provide functionality for both Windows, Linux and Mac users and there is so much code that we could begin to bring into the ecosystem.  

 

Batch message class should have a public static method to build a batch message that can be sent to the Time-Delayed Message.vi.

tkendall_0-1643323757644.png

 

I would like to wait xxxx ms then send three messages in order.

tkendall_1-1643323849848.png

Yes there are twelve other ways to do this but this would be much cleaner and it is an easy one change.

Allow type casting between Strictly Typed VI References

TypeCastVI.png

Why:

The asynchronous methods require strictly typed VIs. Strictly typed VIs depend on the connector pane and terminal wiring type (Required, Recommended, Optional). Depending on your development environment and configuration options (Front Panel > Connector pane terminals default to required), newly connected terminals may be Required -or- Recommended. 

Opening a VI reference or calling an async method with the wrong terminal wiring type will result in Error 1057: Type mismatch. 

TypeCastVI_Justification2.png

To work around the connector pane variance, we need to type cast check every connector pane terminal variance in order to call the proper async method without getting the Type Mismatch error.

TypeCastVI_Current.png

The amount of unnecessary complexity to call and collect a thread is infuriating. There is already enough complexity when it comes to spawning a new threads; between the conditional options (Non-Reentrant, Reentrant, Async Forget, Async Collect), VI type specifier (Generic, Strict), Connector Pane Type (Pattern, Rotation), Terminal Wiring Types (Required, Recommended, Optional), etc. Threading in LabVIEW needs improvement.

Idea:

To better support Asynchronous calls, we need the ability type cast the required strictly typed VIs to:

1. Add an option to Start Asynchronous Call and Wait on Asynchronous Call methods to ignore the VI terminal wiring type flags:

     Required (0x21000), Recommended (0x20800), Optional (0x20000)

2. Support type casting VIs To More Generic Type and To More Specific Type to avoid the error 1057 Type Mismatch all together

TypeCastVI_Idea.png

Regards,

A LabVIEW Enthusiast 

It makes no sense to write the channel name every time with TDMS write. You could easily improve write performance and disk utilization if you stored the channel names once and used a smaller alias to them (see example below). There are other work arounds including buffering

https://knowledge.ni.com/KnowledgeArticleDetails?id=kA00Z000000P9reSAC&l=en-US

But the downside of buffering is that the data is stored in memory so if you lost power, you would potentially be missing a large chunk of data. Also, this solution is compatible with the buffering idea in that this would make the files even smaller.

In my example even after just 100 writes, the example using the lookup table is 20% smaller.

We can also get even bigger gains if instead of using hex-ascii strings for the short names, we used an integer.

 

TDMS long name lookup.png