LabVIEW Idea Exchange

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

I think the Array Element Gap should be sizable. This would facilitate lining up FP arrays with other items on the FP, or simply as a mechanism to add more apparent delineation between elements.

The size should be set in the Properties box, not by dragging the element gap with the mouse - that would add too much "cursor noise".

A new Property Node for this feature would complete Idea.

 

GapSize.png

After reading Jim's idea "Need a way to visualize VI call chain hierarchy in LabVIEW" I thought that in addition to that, it would be nice to see which VIs have execution highlighting ON. A bonus would be to be able to turn all OFF.

 

Sometimes, I use the execution highlight to see which subVI is running and not coming back, but then if I forget to turn it off. The result: my application runs really slow and I have to browse through several open VIs to figure out which one has execution highlight on. 

 

Jim had a good point that it would be nice to have a scripting property: "HighlightedExecutionEnabled".

Currently errors can be connected to the case structure and appropriate case can be executed.

Many languages do error handling with try catch type of code, I think a structure like it would be much more efficient than propagating errors.

ErrorCases.PNG

normally code will start execution from code case, if any error occurs then it will immidiately switch to error case, and irrespective of error occurance finalyy case would be executed in the end.

 

 

(not really related to this idea)

 

Deferring panel updates is a tedious procedure, requiring a panel reference (not intuitive to get!) and a couple of property nodes. However, deferring panel updates is sometimes very important. For example when coloring the fields of a large table according to their values, a serious performance impact is encountered unless we defer panel updates. There are many other situations where panel updates should be suspended temporarily, especially if property nodes are used in a tight loop.

 

My suggestions is to make flat sequences a little bit more useful by adding a new function to the right-click menu of each frame: "Defer Panel Updates". Now a new connector will appear on the frame that accepts a panel reference. If left unwired, this applies to the panel of the current VI, but we can wire a reference to any panel we desire (useful for subVIs). There should be a visual indication indicating that updates are deferred, e.g. a slightly different background pattern (e.g. faint checkerboard or similar). Note that this idea does not clutter the palettes with a new structure, but simply extends the functionality of existing elements. Let's put those sequences to some good use!

 

During execution of such a frame, the panel updates are deferred and automatically enabled again once the frame ends. The configuration should be "per frame" of a multi-frame flat sequence.

 

This has many advantages over the current situation:

 

  • It is immediately clear what part of the code executes during the deferral
  • The deferral is clearly delimited and it is not possible to accidentally forget to re-enable the updates
As an example, here is my subVI code to color the fields of a large correlation matrix (located on the main VI) according the respective value so we can easily pick out where correlations between fitting parameters are a problem.
TOP: current solution. BOTTOM: how it could look like with this idea implemented.

 

 

I have a Group of numeric values.Such as

1.0

0.866

 0.5

0.2

0.1

0.0

I want to create and update a drop down menu so a user can select a numeric value(Direct calculation,do not Converted form a string), a bit like a combo box.

 

DBL to DBL.png

 

Hope to have this controls in the labVIEW!

 


Very often during debugging, you have probes placed all over the block diagram checking wire contents. It would be really convenient if during Run Time we could place more Free Labels, as this would allow a developer to place comments during debugging/running, otherwise you have to stop the VI and then try and remember all the comments (assuming you have not written them down).

 

Note: I do not know of any other languages that allow you to do this, as you are essentially changing the source on the fly, so I don't think this is a trivial change! (But LabVIEW is better than other languages anyway Smiley Tongue)

Is there any tool to compare Multiple VIs (more than two i.e. about twenty) at a same time.How can I compare more than two VIs at the same time. I am an Lab Engineer I have to check assignments submitted by students and I want to know how many of them are copied from each other. Labview compare VI can only compare two VI at a time while I want to check about 30 VIs at same time.

When you're running an executable and it freezes, especially in development mode, you have to shut down the entire LabVIEW environment.  It would be nice if there was a way to stop just the executing VI.

Cuando tenemos en funcionamiento en tiempo de desarrollo un VI, que no tenemos activada la barra de herramientas de debuger, no es posible parar si ejecución, esto es especialmente grave cuando hay un error de programación y estamos en un bucle sin fin, o otro caso mas grave, es cuando un vi que tenemos como modal esta abierto en el tiempo de desarrollo, pero no esta en ejecución, por que no ha sido todavía llamado por el programa, este vi se pone en primer plano, y como no tiene código funcionando no tiene posibilidad de salida, con lo que impide cualquier acción sobre cualquier otra ventana, inclusive la del proyecto.

 

Seria necesario que la interrupción, del ctrl+., o cualquier otra estuviera vigente siempre, para poder detener la ejecución en tiempo de ejecución.

Build Array Ordering.png

 

Appending to the end of an array is much more efficient than prepending to the beginning
If you need to insert items at the beginning, insert at the end instead and use a single Reverse Array when finished

 

 

Insert items.png

How about make a new array function that can insert items at the beginning efficiently?

I've recently run into an issue when using external code (ActiveX to be exact) where I needed to explicitly call garbage collection in a similar fashion to how it's done in C# (C Sharp).

The "Request Deallocation" function isn't true garbage collection.

 

A C# example would be:

someComObject = null;

GC.Collect();

 

 

There are situations where it is neccessary to explicitly call garbage collection.

What bugs me about the VI Profiling Tool is that it is not intuitive.  The information it provides is really useful; however, it's so hidden and difficult to interpret that few people actually know where it is to use it.  Let's say you are simply acquiring data using DAQmx and writing that data to a file, as below:

 

Block Diagram of Inefficient DAQmx and File I/O

 

You might want to find out how to make this more efficient, but the only way you know is to insert Tick Count VIs and wrap your wires through sequence structures to do it.  It's annoying, and there are other ideas from JackDunaway (here) and JohnMc19 (here) which aim to simplify the use of those VIs. 

 

But why re-code your application when the VI Profiler can do it for you?  In addition, the VI profiler has more timing information (longest, shortest, average, total, etc) as well of number of runs and memory allocation data.

 

Good news: VI Profiler makes getting the data easy. 

Bad news: VI Profiler makes using the data difficult.

 

Why Using the Profiler is Difficult

 

First, you need to know it exists among a number of bland and condensed gray menus (Tools>>Profile>>Performance and Memory).

 

Next, you have to coordinate starting the profiler with starting your VI (start the Profiler, then start your VI, then stop your VI, then stop the Profiler).

 

Finally, you have to dig through a TON of VIs to find the ones that are relevant (I assume this is because, for polymorphic VIs, all of the instances are loaded into memory, even the dozens that aren't currently being used.)

 

When you find the VI you wish to examine, it will look something like this:

 

VI Profiler Currently

 

Have fun sorting through that!  When I finally find a VI that's hogging memory or speed, I'd expect to click on it to navigate to that VI.  NOPE!  All the VI Profiler does is make the line bold.  Not particularly easy to use...

 

I can't say if it's possible to get rid of VIs that aren't being used, or to make the menu option more visible to the user, but I do have an idea or two for how to make this information easier to understand in LabVIEW.

 

So here's what I suggest:

Adding a couple of check-boxes to the top of the VI Profiler will view in relation to your LabVIEW VI.  Notice the extra check boxes in the top of this image. 

 

VI Profiler With Color Shading

 

One checkbox allows you to color the column you wish to highlight in your LabVIEW code.  The other checkbox inserts a text comment containing the highlighted data straight into you LabVIEW code (right next to the sub VIs):

 

Shading SubVIs According to Relative Execution Speeds

From the above picture, you can clearly see the Write to Spreadsheet File VI is the slowest to execute.  Next in line are the Start DAQmx Task VI and then the Stop DAQmx Task VI.  So if a developer wanted to find out how to make his loop run faster (and therefore increase the rate data is read from his PC RAM), he would know the VIs that are more red are the ones he needs to focus on first.

 

Also, if a user wants to highlight the memory usage, he could select a memory column from the VI Profiler.

 

Highlight Average Memory Usage Per VI 

 

Then the LabVIEW block diagram would look like this:

 

Block Diagram Shaded in Blue for Average Memory Usage

In this case, if a developer wants to find out how he can optimize his code for memory usage, he knows where to start.

 

Side-note: I think selecting multiple colors at a time (one for each column of data you wish to highlight) would be cool, but that would start to get messy on the block diagram.

 

Other data, like the number of runs, could highlight which sections of code are running more often than others.

 

If we integrate the VI profiler more effectively into LabVIEW, there are a lot of benefits:

 

1. Re-coding to find timing specs won't be necessary for Sub-VIs

2. Monitoring memory allocations much easier (some users don't know it's possible with LabVIEW).

3. When there's a problem, it's easier to understand which SubVIs are slowing down code or hogging their memory.

4. Developers can further code development WHILE being wary of inefficiencies.

5. More integrated development environment "feel" for new customers or the experienced G-coder.

 

Please let me know what you think!

Display VI version in Tools bar For any vi

 

vi.png

 

My use LabVIEW 2010,Often saved a vi(8.5) as high-version .

 

Alternatively, when saving the vi, the programmer could be proposed to choose the former LV version.

 

Sorry ,My English no good.

I think it would be a good idea to have a tool integrated into LabVIEW that would let you view the amount of time it took to run your VI.

There has been a few posts in forums asking for programmatic ways to do this, but this way would answer them all:

ideaexchange.png

 

Clicking this would allow you to see the time it took for the last run of your VI to execute. Making it quick to see if and acute changes made to your code had made this more efficient (time-wise).

 

An improvement to this would be to have a sweep like feature on your block diagram that you could set up multiple markers to see the time taking for your code to reach them.

A bit like this:

sweep.png

 

These markers would be moveable and their values would update after execution.

 

These are just ideas, I'll be glad to hear your comments!

 

Regards,

How to create a standalone executable in LabVIEW 2009 Professional Development System?

The attached screen shot contains the screenshot of the mesage I get when I attempt to run the exe created.This may help you suggest a solution.

When designing large applications it is normal that the top level VI will spawn background tasks to perform specific tasks. It would be nice if the top level VI could receive an event when the subVI exits. I realize this is possible if you specifically add code to the subVI to post a message to a queue or fire off a user defined event. However, it would be nice if the event were available without the need to add code to the subVI. This would make it easier to design top level applications that could spawn tasks and not palce any additional coding requiements on the subVI. The "Panel Close" event can be used with callback however it will only trigger when the subVI exits via the Window Close button (X in the upper right corner). This is too restrictive and will not allow the top level VI o be informed the subtask exited programmically.

Multi-Threaded Interrupt Management Capabilities in LabVIEW

 

Background

 

            Event interrupt management works well in LabVIEW if ones’ programme is small and developed within a single overall Event Structure, encapsulated within a While Loop.

 

            The problem comes when the software architecture demands a separation between the User Interface management (interrupt) functions and the sequential and looped programme structure (executable) components of the code for modular programming. In this configuration, waiting for Events to occur before code execution, pausing code execution (once started), stopping code execution or even aborting code execution (with the ability to close the application down cleanly prior to code exit) become challenging operations to implement within LabVIEW.

 

            This software architecture design challenge is exacerbated, if branching within the looped programme structure (executable code segment) is also a requirement.

 

Two Key Requirements

 

            Ideally, the following two capabilities, if implemented within LabVIEW would solve all of the aforementioned problems:

 

  1. To be able to interrupt a While Loop, pause it and if appropriate reset the [i] loop index back to zero. If controlled via the Event structure, this would make both Event structures and While Loops compatible with each other, which is not the case today.
  2. To be able to interrupt a Flat Sequence or Stacked Sequence structure and break out at any individual “Frame” in that structure, based upon a specific Event interrupt or even an Abort, which when controlling hardware can be a critical request that requires immediate action! Today, it is not possible to break out of a Flat or Stacked Sequence structure, one has to wait until the complete Sequence has executed.

 

Current Tools

 

            Current LabVIEW, if used with care, can overcome to some extent the current While Loop and Flat Sequence software architecture limitations, but they are very cumbersome to use and require an "eagle eye" and good software tracking and debugging skills!

 

While Loop with Pause and Stop buttons

 

Set Occurrence

 

Wait on Notification (Front Panel activity)

 

A not yet fully complete explanation of the key multi-threaded programming issues is attached. If it requires updating to make it complete, do let me know.

 This would be a method on a VI that puts all properties for all controls and decorations back where they were when the panel was saved including moving positions, sizing, making visible controls visible and hiding invisible ones, etc. as well as sizing and scrolling the panel to its saved origin. There's "Revert VI", but I don't want to unload the VI -- the VI might be running when I want to call this method. Indeed, most often I would want the VI to call this method on itself. This is a method that needs to work in the runtime engine.

 

The goal is to be able to restore an interface to some known starting position before allowing various plugins/3rd party VIs to modify it, and to be able to repeat that cycle. Since it is impossible to know all the things that those third party VIs might change, a single "reload the panel from disk" method would help a lot.

Pop up on a subpanel control. There's an option for "Make Panel Transparent". When you enable that, the background of the panel is transparent and you can see controls/indicators underneath. The key word here is "see". You cannot click on those controls. The subpanel eats the mouse clicks. I talked about this with a couple people and could come up with no use case where you would want a transparent subpanel and not be able to click on the controls behind it. What I think the behavior should be is "if the mouse click hits a control in the subpanel, that control gets the click. If no control in the subpanel gets the click, the click falls through to the controls behind it, if any."

 

I'd really like the ability to write some metadata information in the PNG Write (and read from Read) VIs. JPG, BMP would be nice for completeness.

 

Lately I'm using PNGs a lot. The W3.org spec and most PNG readers allow the use of the "tEXt" chuck tag to allow labels for simple text, keywords include: Title, Author, Description, Copyright,... -- simple stuff.

 

I'd modify the built-in "Write PNG File.vi" but it is password protected 😞

 

My workaround is to write the PNG normally, then tweak the binary file, inserting the tEXt chuck myself, just before the IEND tag, with size and CRC-32 considered.

 

I would really like to see it built in. Perhaps a cluster input with some of the reserved keywords. It seems functionally like a simple concatenation on the file IO stream prior to IEND and file close.

 

Here's the W3 spec for PNG

W3 PNG Specification

 

Thanks!