LabVIEW Idea Exchange

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

All the other Build Specification has already this function available. Why not the Installer and the ZIP File.

 

Dany

By default, when you build an application, the front panels of all VIs are removed.

 

Of course, this would make applications completely unusable, so there are certain changes which cause LV to keep the front panel in, such as setting the front panel to open when the VI is called. This gives LV a clear indication you want the front panel and these changes are generally enough for most of the VIs which people use.

 

There are, however, times when you want a VI to keep the panel, but it's a VI which usually (or sometimes even never) won't be displayed. Today there are several ways to handle this case.

 

 

The official way is too flimsy:

 

Keep_FP_AB.png

 

 

It's limited to specific build specs and it's too easy to break (e.g. remove the VI from the project and add it back).

 

 

 

 

The automatic way relies on additional changes you're likely to make if you intend to show the VI, but is also too easy to break:

 

Keep_FP_Property.png

 

Someone could just unset the property and then it's gone.

 

 

 

 

What I usually today is something like this:

 

Keep_FP.png

 

The static property node ensures the FP will remain and the comment makes it less likely that someone will remove it.

 

 

 

 

What I want to see, however, is something more explicit, possibly in the shape of a new VI property:

 

Keep_FP_New_Property.png

Please add the circle constant tau, to the Math & Scientific Constants palette.  Happy Tau day!  (see more at http://tauday.com/)

 

Tau Constant

It would be nice to have the F2-function in LabVIEW (mark element and press F2 to edit text).

So you don't have to step through the Tools-Palette.

 

When using the Sahred variable (SV) with "Bind to source", the SV uses the datatype of its source.

If you are using the datatype "double" you can see all fractional digits.

That doesn't make sense all the time - e.g. if you want to display temperature values.

 

Our idea is to give the user the opportunity of controlling the number of digit of precision.

 

Digits of precision.jpg

 

Thanks

It would be very helpful if the Event Structure had a little icon that shows if the event Locks the Front Panel:

 

Front Panel Locked:

21161iBA922ECBE615130B

 

Front Panel Unlocked:

21163iFA7A2220EBC06692

 

The first image has other examples of the "lock" icon, all taken from the Icon Editor glyphs.

 

Thoughts?

As described in the following "Darren's Weekly Nugget" posting, LabVIEW provides an API for programatically building projects. Especially when dealing with large projects, this can be a real time saver and great technique for quality control (ensuring that the build process is carried out the same way each time). However, when doing a programatic build, there is no status information - the LabVIEW application that calls these APIs is just left, giving the impression that it has locked up. This can be especially concerning given that builds of complex applications can take quite a while.

 

A solution seems pretty straight forward - give the build API calls, the option to display the standard building dialog.

 

A simple boolean value could allow an API user to provide some feedback to the hosted application as to what is going on without any of the complexities of other status feedback mechanisms (although *any* mechanism would be better than none!)

 

Weekly Nugget Posting regarding App Builder API: http://forums.ni.com/t5/LabVIEW/Darren-s-Weekly-Nugget-02-15-2010/m-p/1072575

In LabVIEW 2009, the programmatic API for shared variables and I/O variables was introduced. This allows you to reference a variable by name, rather than dropping a static node on the diagram.

 

Some of the benefits are: iterating over many variables with looping structures, creating modular code, and dynamically accessing variables based on names in a config file for example. 

 

Programmatic access to single-process shared variables would also be useful.

 

(Single-process variables are effectively global variables (not network published), but use the same static node as the shared variable and are contained in project libraries.) 

 

The "Array to Cluster" primitive should allow you to pass in a cluster type.  This allows the output of the primitive to know the names of the elements, as well as how many there are.  If the cluster type is wired, you would not need to specify Cluster Size.

 

array to known cluster.PNG

The current behavior of "Clean Up Wire" will route wires straight through transparent free labels and object labels (confirmed this behavior on 8.6.1 and 2009). I propose that the action routes wires around labels, not through them.

 

CleanUpWire.png

Problem: 

When handling larger data blocks I get "not enough memory" error messages with only option to kill the executable (from time to time, but usually unwanted Smiley Wink ).

Most of the time this involves array functions (initialize array, build array, etc). As this problem is also related to the used PC it cannot be tested (easily) on a developer machine before deploying the executable to a wide range of computers...

 

I propose the idea to enable some error handling in such cases. This could be done in two ways:

1) Add error output to array functions. This could be available optionally by right-click menu so you don't break older code. Output would be an error stating "Not enough memory for operation ..."

 

2) Add a new application event "Application.MemoryAllocationError". This way the program the program can atleast catch the problem. (Inspired by "OnError" constructs of text-based programming languages...)

Sort event sources in the event structure when addind an event. Case insensitively...

 

sort event sources.jpg

This is something that would be a great addition for those of us working on different platforms (i.e. Windows and RT).

 

When a VI is compiled for a particular platform, add a seperate area to the actual VI file to keep the platform dependent compiled code. This way a vi that has been compiled for use on windows and for RT would have two sectons that keep a seperate copy of the actual machine code for each OS.

 

Where this issue becomes a problem is when you have common code called from a project that has both Windows and RT components. This creates an endless recompile operation as code is built

 

As an example:

 

Code is compiled for Windows.....windows machine code is generated and saved in the vi

Code is opened under RT.....changes pending because the compiled code does not match the platform

Recompile vi for RT....RT machine code is generated and saved in the vi.

 

When the code is reopened under Windows, it requires another recompile due to the existing RT machine code.

 

Obviously any changes to the FP or BD would cause all of the machine code areas to require a recompile. 

 

This would add more size to each individual VI, however disk space is relatively cheap with respect to LabVIEW development systems.

Right-clicking on a case structure, we still have the option to convert a case structure to a stacked sequence.

 

I would prefer if this option would disappear without a trace forever :D. It has no purpose in life!

 

Nobody should ever use that option! It makes no sense!!! 😄

 

 

(I would probably retain the option to convert a stacked sequence to a case structure)

Add italic and underline to the supported text formats (only bold at this time) for the VI description (--> context help of VI).

 

Integrate the VI description in the long awaited icon editor (see this post), so we can edit the icon and the description in one step. Doing so, spare us to type characters like "<B>" and "</B>" by providing formatting buttons !

Like it or loathe it, Microsoft Excel is heavily used for storing, recording and analysing lots of data and many LabVIEW programmers must find they need to get data into or out of Excel. However LabVIEW lacks the ability to read and write Excel files directly. It is possible to exchange data with Excel via ActiveX automation, but this:

 

  • requires Excel to be installed on the same computer as the LabVIEW application
  • is not cross platform
  • is complicated to do
  • does not appear to work reliably across different versions of Excel

 

The Report Generation Toolkit allows creation of Excel files but this costs extra and is not cross platform. 

 

Many software packages can read data directly from Excel .xls files (e.g. Umetrics SIMCA-P) and presumably it is therefore also straightforward to write data out in Excel .xls format. Native LabVIEW functions for reading and writing .xls files - for example, into string arrays - would be very useful. It would not be necessary to support formatting, charts etc - although some kind of basic formatting support might be useful.

 

Of course it is possible to exchange data with Excel via delimited files (comma- or tab-separated values) but the .csv format requires characters such as quote marks, commas and carriage returns in a string to be escaped so that they are not incorrectly interpreted as part of the file structure. Tab-separated files suffer less from this problem but on Windows at least, files with a .tsv extension are not automatically associated with Excel whereas .csv files are. It would be helpful if LabVIEW also had native functions for reading and writing .csv files with correct escaping for Excel.

Currently if you create a new VI for override, whether or not the terminals are displayed as icons is determined by the VI being overridden (e.g. overriding Actor Core.vi will always give you terminals as icons). Instead, I propose that it be determined by the user's preference in the Tools--> Options menu. If we've said we don't want terminal icons, shouldn't all newly created VIs respect that?

On bigger projects, when creating a new class, I find it time-consuming to track down the parent class I'd like to inherit from.

 

It'd save me some pain if there was some kind of filter and/or search option for this on the New Class GUI:

 

_carl_0-1614272545841.png

Other thoughts on this:

- While the tree structure is useful, I usually know the name of the parent class I want to inherit from, but I don't necessarily know the full inheritance of it, meaning the tree structure isn't the most efficient way to find it.  (Even alphabetical by class name would be faster in these cases).

- I'd find the tree structure here easier to follow if the lines were visible.

Currently, DETT looks like this:

Taylorh140_0-1588782161680.png

But it should look like a proper profiler allowing for exploring and easily visualizing performance, threads, call stacks and memory usage at a glance (similar to this):

Taylorh140_1-1588782422432.png

 

 

 

This idea has come up repeatedly over the years: a new VI created in a library* should default to private scope. The point of private scope is to limit the number of callers of a subroutine so you can freely refactor the subroutine and know, without question, that the only callers that you can be affecting are the ones inside the library. This allows you to make API breaking changes freely because you can know you are updating all the callers. Note that if we did this, it would almost certainly have a Tools>>Options setting to change it, but the idea is to make "new VIs start in private scope" be the shipping default.

 

Each of the other scopes is more permissive in some way, with public being all the way open. For APIs intended for reuse and long-term stability, use of those other scopes ought to be a conscious decision.

 

The vast majority of VIs within most libraries should be private. There are some weird exceptions**, but most libraries have a few routines intended for the world to call and a bunch of subVIs that support the public ones. But going and setting the access scope to private is a lot of work, and many developers never think about it. For small shops, this isn't usually a big deal, but the larger the dev team, the greater the danger of highly interlocked libraries caused by someone reaching for some deep subroutine that just seems so useful, instead of doing the right thing and refactoring that VI out into its own shared library. 

 

I've seen some of our customers get really badly bitten by this, but it is an issue that takes years to build up, and then requires expensive refactoring projects to fix (or cloned code, which is sometimes worse in the long run).

 

C++ and C# default everything to private unless you declare public; I think that's true in most text languages.

 

But LV is a programming language for non-programmers, and not everyone needs to understand access scope, so creating new VIs as private by default would push yet another concept into the "you must learn this" category instead of "learn this when you hit a scale where it is useful" category.

 

In the end, I think access scope is a simple enough concept, one that most people using libraries get familiar with pretty quickly, and switching something to public is easy enough to do. Therefore, I think switching the default would do more good than harm. So that's what I'm proposing here.

 

* includes plain .lvlib libraries, XControls, LabVIEW classes, state charts, and any other type of library NI may introduce.

** such as the NI Analysis library, which is hundreds of VIs packaged together, mainly for licensing reasons, less because they have shared functionality.