LabVIEW Idea Exchange

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

It has been a few months since a suggestion has been made to do something about the For Loop, so if nothing else it is time to stir things up a little bit.  There have been several suggestions to do something with the iterators, for example:

 

http://forums.ni.com/t5/LabVIEW-Idea-Exchange/Smart-Iterators-with-Loops/idi-p/967321

 

http://forums.ni.com/t5/LabVIEW-Idea-Exchange/for-loop-increment/idi-p/1097818

 

http://forums.ni.com/t5/LabVIEW-Idea-Exchange/quot-Start-Step-Stop-quot-structure-on-For-loops/idi-p/1022771

 

None of these has really gained traction, and heck, I haven't settled on any of them myself.  In most cases I am satisfied with a workaround, usually involving the Ramp VI.

 

There is one case where I am not happy with the workaround.  I happen to need reverse iteration values quite often (N-1,N-2,...0).  With the N terminal pinned to the top-left corner I have little choice but to do the following and start zigging and zagging wires:

 

18391iB5AE9450400CAAD6

 

I would simply like a reverse iteration terminal which can be moved around at will and simply counts down.  Doesn't have to look like I have drawn it, that just happens to be intuitive to me.  Naturally this terminal (and the normal iteration terminal) should have the option to be hidden.

 

I thought about having the option to have the loop spin backwards, similar to reversing all auto-indexing inputs and having the iteration terminal count down, but I just could not decide what to do about auto-indexed outputs.  My G-instincts tell me that they should be built in the order of loop cycles, my C-instincts tell me I am building array[i] and if i goes in reverse order, so should the array elements.  For now I say, forget it, and just stick to the simple terminal.  Array reversal is essentially free, so I at least have a workaround there.

Hi,

 

It would be awesome if there was an option in project window to set if the method is contained within a .lvclass file or ouside of the .lvclass next to it in the folder.

 

Now it's like this:

HowItsNow.png

 

It's hard to use a class like that in a plugin architecture with VIs on the outside. Lets put everything together inside like a LabVIEW LLB!

 

How it should be:

HowItShouldBe.png

 

Don't get me started on Packed Project Libraries 😉 We just need LLB functionality, for the class to behave like a folder and we are happy 🙂

 

Piotr

Please add to the right-click Cluster popup menu a Remove Cluster item analogous to a tab control's Remove Tab Control removes the parent container and leaves the contents as-is.

The LabVIEW IDE may coerce diagram constants when the enumerated typedef changes.  The problem is: the constants may occur in many places, and the coerced value is not necessarily helpful.

In the pictures below, the "Idle" element is removed from the typedef and the IDE coerces the diagram constant to a neighboring value "triggered".

Before.png

Now the program behaves as if triggered. 

AfterEdit.png

 

When a diagram constant becomes invalid, wouldn't it be better to flag it as broken, so that the programmer is forced to handle the problem?

OpMode.Better.png

In LabVIEW we can dynamically run a VI in a few ways:

a) If it's not running Top Level VI or if the VI re-entrant with the Run method.

b) Already running as sub VI, with Call By Reference.

c) Make a new VI and drop the (running) sub VI on the diagram.

 

Downside of a) is we can't always make sub VI's re-entrant, but still want to call it by reference. Downside of b) is we need to know the strict type (connector pane). Downside of c) is we might end up with a lot of VI's just to function as Top Level VI for the sub VI's and it doesn't work in executables.

 

I like to propose a method, so we can dynamically call a sub VI without knowing the strict type.

This is all I want.png

Using it, we enable LV to dynamically run sub VI's while setting\getting it's parameters by name.

 

For sub VI's (already running) this method will act as Top Level VI. For Top Level VI's it will fail unless it's idle.

 

 

 

(Please ignore my first confusing attempt)

Panel Actors provide a very extensible UI tool.  There is simply nothing better than panel actors to build composite UIs, but we are still limited in that we can only insert UI elements into existing sub-panels or new windows.  What if there was a simple function called Create SubPanel.vi with inputs of size and position, and an output of the reference to the created subpanel?  What if closing the subpanel reference removed it from the front panel.  Now we could create an infinitely complex UI at runtime.  It should be a simple matter to build special support for this into the runtime environment. (I actually have no idea how hard it would be)

 

Use case: an acquisition UI with pre-defined display elements (graphs, gauges, numeric boxes, etc, etc), all created as individual panel actors.  The user asks for a new graph element display during runtime.  We programmatically drop a subpanel and then spawn the requested graph actor into it.  User wants it moved, and we can do that with mouse events.  Same for resize.  User wants it gone and we can do that too.  User wants 10 elements or 10,000.  We can do that with no problem.  Give us this and we can create literally any UI of any complexity, fully configurable by the user. 

When tabs are on the side, the text should be correctly oriented:

tabs.png

Have all the infos about selected control/indicator in one place!

Just click and move easily through the block diagram!

 

Use the Control/indicator dashboard!

 

 

dashboard.PNG

The Run Method is pretty much the only option we have in LabVIEW to scale an application dynamically by instantiating new VIs - but there is one big catch - for some reason it requires the unser interface to be idle(!).

 

Related methods like setting control values e.g. do not have this requirement so they do not pose a problem - but the main method for dynamic instantiation does - and can be blocked by something as simple as a user that opens the calendar view of a date and time control (which of course never should do this either, but that's another issue/idea).

 

Personally I use the run method to create new trend windows (you never know how many trends a user wants to see at the same time), create session handlers for remote clients etc. The times it is used to actually create user interfaces it is not a big problem that the run method is in the user interface thread, but for session handlers and other things that needs to be created in the background based on requests from the outside? A HUGE issue.

I think it would be very nice to add these. A common task is to get object position/sizing pixel perfect. Adding these buttons would help tremendously with that, there is plenty of space for them, and I feel like it would be a minor developmental effort. Upvote if you like it, thanks for reading 😀

 

FireFistRedhawk_0-1638369163977.png

 

To support modern web thin clients, the LabVIEW webservice needs to support the OPTIONS request. When a web browser makes a cross origin request there are a few rules that the response must comply with before the browser will provide with the result to the web application. The OPTIONS request is needed to respond to these requests.

 

A cross origin request is any request where an application running on one domain needs to make a request to another domain. For example, if there was a javascript application running on the domain www.labview.com and it needed to make a AJAX request to api.labview.com, the browser considers this a cross origin request. This is a common setup when the thin client is being hosted by one server, and the webservice is being hosted by another server. https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS

 

Depending on the request, the browser may issue a "preflight" request. "Standard" requests are GET and POST requests without custom header fields only require the response has an additional headers. Other requests (PUT, DELETE, GET w/ headers, POST w/ headers) require a preflight request. A preflight request is an OPTIONS request. If the OPTIONS request doesn't get an appropriate response, the browser will not even make the actual request. https://developer.mozilla.org/en-US/docs/Glossary/Preflight_request

 

For example, I'm starting an application and here's how I'd like it setup.

 

1. Windows PC. This is the central server for the application. There will be a normal LabVIEW application running on this computer. There will also be a web service run on this computer. The web service will mainly host a web application written using HTML/CSS/Javascript (although it could be written using HTML vis from NXG).

 

2. A bunch of CRIOs. These CRIOs will also host their own web service to get system information, measurements, and diagnostics. As new CRIOs are commissioned, they'll report to the Windows PC.

 

Now a user uses their web browser to access to the windows PC. The Javascript Application (which is hosted on the Windows web service) provides the user with a list of all commissioned CRIOs. They then click on one and the javascript application starts to make requests directly to the CRIO's web service. Since these CRIO's are on a separate IP address, the browser flags this as a CORS request. This means that an OPTIONS request can be sent. Since I can't handle an OPTIONS request in a LabVIEW web service, I can't implement this.

 

This is just one example. Another case would be an Apache hosted web application hosted on an Amazon EC2 needs to make requests to a LabVIEW web service running in a different domain. Basically any time a web application (AKA something running in the browser) needs to communicate with a LabVIEW web service you'll run into this problem.

structure_merger.PNGEvery now and then I (or others) have two case or event structures that I would like to merge, either completely or just copy some cases from one to the other. If we are talking about one or a couple of cases, doing it by creating empty cases and copying the code from one structure to the other as is the option today is fine. If the number is much higher this gets quickly tedious, and we have to come up with alternative solutions.

 

(Making a subVI of the two and add another case structure around them, as described in the discussion linked to above, is one -  but that changes the layout and adds another selection to the logic).

 

So how could it be handled by the IDE instead and made much easier?
A case merger function.

Here are a few quickideas on how to implement it (but any similar solution would be better than none);

 

  1.  Copy-Paste-Merger: Selecting the frame of structure 1, copying it, selecting frame of structure 2 and pasting will bring up a merge dialog with the following options:

    a) Replace structure?
    b) Merge structures (all cases)?
    c) Merge selected case only into structure?

    Now if the user selects to merge the whole or just the top/selected part of the structures (b or c) the function has to handle overlapping cases (just like the OS does when copying into a folder with existing content) by asking the user whether to keep the old ones, replace with the new ones or leave them as non-unique values (or add an index to the value) for the user to tidy up manually afterwards.

  2. Drag and drop merger; identical to the previous suggestion - but instead of copy/paste the transaction is initiated by dragging structure 2 over structure 1 and e.g. holding it with an edge aligned when dropping to indicate that it is not intended to go *into* the other structure.

  3. A merge option that can be called from the menu or contextual menus on case/event structures. The advantage of this would be the ability to add more complex mergers where you would want to pick frames x, y and z from structure 1 to merge with structure(s) 2 etc... This option could alternatively be combined with the other two and used as the dialog when those are initiated.

If you drag an icon from one vi and drop it on the other it is a convenient way to quickly copy icons.

 

The downside is that this action causes the icon to be flattened and all of the layer information lost. It would be nice if the layer information were preserved. 

(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.

 

 

From my experience, it would be more useful for terminals on the connector pane to default to Required instead of Recommended.

 

terminals.png

 

Here's my thinking:

 

  • Usually You Want It - In general, when you create a SubVI you require all of the inputs, in which case it is a pain to go and change every terminal individually to required.
  • Conscience Programming - If you are creating inputs for your SubVI that are not required, chances are you are very conscience of this, have done it intentionally, and written code to handle that case where the terminal is not wired.
  • Easier Debugging - If Required terminals are not wired, VIs will be broken, i.e. you have compile errors instead of run-time errors.  These are much easier to debug (especially when the errors appear on functions inside your SubVI that did not receive their required inputs).  If in fact the terminal should not be required you are prompted to make that decision, instead of finding at run-time that your program does not work as expected.

I completely understand why we need these three categories.  However, it seems that the usual use-case is and should be Required and therefore the default should refelct this.

 

Chris V

I find myself often wanting to copy (to the clipboard) a VIs fully qualified name (i.e. including it's library and class prefixes), so that I can paste somewhere else, like in documentation, emails, code, etc.  However, it's not possible to easily do this.  I LOVE that I can copy a VI's path on disk to the clipboard from the VI Properties dialog, but it would be great if it were possible to also do this with the VI's fully qualified name (as shown in the screenshot below).

 

2011-08-06_13-46-14.png

99% of the time when I use a Diagram Disable Structure, I am disabling code with an error cluster wired through. I don't want to lose the errors coming in, just the single operation, so I manually wire the error cluster through the empty case each time.

 

I've talked to others in the past about this and it would be nice for LabVIEW to be all-knowing and wire all datatypes through that match, but that would definitely lead to conflicts and mistakes. Error clusters, on the other hand, are simple are nearly always a single wire in and out.

Simply auto-wiring the error cluster input to the output would make the debugging process much easier.

 

Code with disabled operation:

Disable.PNG

Its possible to stack plots using a WaveForm Chart:

 

Capture.JPG

 

You can also do it using Mixed Signal Graphs.

 

 

But the functionality is very restrictive.  I propose these improvements:

 

  • Allow stacking plots on Waveform Graphs and XY Graphs also.
  • Allow users to modify the number of stacked plots at run-time.  This is currently impossible.  You need to pick the number of plots you want to stack during design-time.  And then you are stuck with it at run-time.  Though there are certainly plenty of clumsy attempted workarounds to this problem (e.g. see here).  It would be great to have this function for run-time.  Its very common in Biomedical data-acquisition applications to allow users to vizualize data in stacked plots (EEG for example), and its a pain to program this in a flexible manner using LabVIEW.

 

The current implementation for remote debugging needs two ports to be opened on a stand-alone firewall in between.

  • Port 3580 to connect to the NI service locator on the target machine
  • A random port for the application on the target to connect to
    This port is dynamically assigned to the application by asking the OS for a free one

 

This dynamic port cannot be pre-configured on the stand-alone firewall except by opening up the whole port rang above 1024.

The latter is something no IT person with any sense of security will do !

 

So we need to be able to pre-configure a certain port for the target application, so that we can open a dedicated port for this connection on the firewall as well.

Otherwise this whole remote debugging feature is useless to many companies.

 

There have been multiple cases in the last few years where customers (huge ones) have come across this issue. 

Title says it all really.

 

Openoffice is cross-platform and free.  All good points.

 

Please?

 

Shane.