LabVIEW Idea Exchange

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

Now that scripting is "legal" we need to be able to do more with it, when it comes to the event structure scripting is weak.

 

Here are a couple of discussions where people wish for more scripting functions around the event structure :

Triggering an event on a picture created with LV Scripting

- Remove Frame Not Implemented

How do I get the cases in an event structure

- Event Structure Selector Labels

 

We need to be able to add and edit event!

Add cmd line parameter to LVCompare.exe which would contain the file name for an image file.  If the image file name exists in the cmd line parameter, create an image file that contains all of the differences between the two vi's.  The images would be the same via LVCompare.exe, when stepping through the differences and doing an equivalent print screen.  It would be nice to automate the process of documenting the differences between two vi'.
Message Edited by Laura F. on 12-17-2009 08:38 AM

Currently the lvsound2 library -- the Sound Input and Sound Output VIs supported by lvsound2.llb and lvsound2.dll -- updates the audio device list from the operating system only when first being loaded into memory. If you change the device list (e.g.., pair/unpair a Bluetooth headset) the device IDs will not reflect the new configuration until all the lvsound2-dependent VIs have been unloaded from memory. After adding or removing a device, the VIs will generate error 4803 ("The sound driver or card does not support the desired operation.") for device IDs related to the new/removed device,  even if the ID is still actually valid and points to something else. This is extraordinarily inconvenient for test systems focused on audio device testing, but understandably a niche issue, which may be why it hasn't been caught before now.

 

In the interim, the workaround is to dynamically call any of the VIs you're interested in to force them to load/unload as necessary. There are two appropriate solutions I can think of:

 

1) Update the Sound X VIs to implement the dynamic call workaround (preferably directly around lvsound2.dll calls so we can still borrow other VIs in the LLB).

2) Update the DLL to support on-the-fly changes.

 

The latter solution is ideal, particularly for performance. This reads both as a suggestion and a bug report so that anyone else who has this problem can find a public forum documenting the issue.

 

This should work!! I know there are workarounds and I have used them but it would be much easier.  

atsrefdsfads.png

 

On Windows, you can define environment variables that auto expand to known directories. There are some variables that are already defined by the system. For example, %TEMP% automatically expands to c:\Users\<username>\AppData\Local\Temp OR WHEREVER THE USER MOVED TEMP DURING INSTALLATION. That's the important part .That makes it possible to write %TEMP%\abc as a symbolic path that works regardless of how the system gets reconfigured.

 

Users can define their own environment variables, and those get expanded when used in a path in the command line or Windows Explorer (the text entry region at the top of an Explorer window). On Linux and Mac, it is the equivalent of using $VARIABLENAME/abc, where VARIABLENAME is some user-chosen name.

 

[admin edit] Added background information on environment variables, and updated title to use the word "Environment" instead of "Environmental".

Hello all! 

The standard LabVIEW plugins are great but operate based on Ctrl + Key shortcut. This means that after a while almost all of your keybord keys can be occupied by a shortcut.

 

Please add an interface for defining commands in the QD ComboBox, which could be used as a more extensible option over single keys.

 

Example - a Dialog command could be invoked like this:

Ctrl+Space -> Dialog Text -> Ctrl + CCtrl+Space -> Dialog Text -> Ctrl + C

 

Example community package implementing this can be found here: https://forums.ni.com/t5/Quick-Drop-Enthusiasts/Class-QD-Plugin-Package/gpm-p/3992772

 

Thank you!

As we increasingly integrate with HTTP servers the LabVIEW functions appear more and more limited.

 

Authentication is a major concern and in enterprise environments one option is NTLM (or Windows Authentication).

 

I would like to see the HTTP client support this as in this case we had to abandon using LabVIEW for the integration.

I haven't tried yet, but this might be already possible by generating C code and then building a Python package from that. It would be nice to have that automated.

I think there's also a commercial potential to sell Vision Assistant as a separate product (to Python developers).

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

A .NET assembly can mark some of its items as deprecated to alert users of those items to not use them for future applications. This is part of the .NET standard. It looks like this:

[Obsolete("This is the message you get!")]

 

In other development environments the developer will see this message when using a deprecated item.

 

This is an example of what it looks like in the Visual Studio editor. The item is underlined and when you hover over, the message is shown:

vseditor.png

 

This is an example from Visual Studio builds:

vs builds.png

 

However LabVIEW does not. If you're developing a LabVIEW application using .NET interfaces... You might use deprecated functionality by accident. To avoid this... LabVIEW users like myself generally have to have intimate knowledge of the assembly or the documentation up on another screen just to make sure they are not using deprecated items.

 

I propose we mark items in a special color to indicate they are deprecated. I chose pink here for no reason. Any color is fine:

lv nodes.png

 

Also, we should indicate the item is deprecated in the class browser in some manner. Again, I just drew some stuff, doesn't have to be exactly this:

lv browse.png

 

It would be great if LabVIEW supported the Python language, including any of its various packages such as numpy. Such computations would be much more transparent and easier to support than calling code in DLLs. They would also be much more open and flexible than the existing built-in computational solutions in LabVIEW, e.g., expression/formula nodes. Currently, I have to call Python scripts via System Exec.vi, which complicates data exchange. (NOTE: I am using an older version of LabVIEW: 2009 SP1.)

I would like the VI icon to be the icon which shows up in the file browser instead of the default LabVIEW VI or control icon.  There should probably be a switch to turn this on and off, since I can see the utility of having a specific icon for VIs, controls, etc., but in normal use, the VI icon would work much better.

 

ExempleWindowsExplorer.png

I hope LabVIEW wishes to become the next-generation all-purpose programming language that will be used all over the world in all industries.

 

.NET and Java are the dominant Technologies in almost the entire world.  With the introduction of the ability to create a .NET Interop Assembly with LabVIEW 2009, I was very excited because I thought that now I could go back to several former employers and make a convincing argument for them to use LabVIEW.... But then I realized,  yes, I can now expose my code written in LabVIEW to .NET applications, but my code cannot do many things which are standard in those worlds.  For example:

 

I can create a .NET Assembly, but I cannot:

  • inherit .NET classes
  • use generic .NET classes
  • create.NET classes that use generics
  • implement .NET interfaces
  • expose a LabVIEW event to a .NET caller
  • expose a LabVIEW class to a .NET caller 
  • cannot create Office Plugins, or any other Plugin that requires me to implement an interface

 

i.e. almost every single financial institution has an in-house developer that creates various Excel Plug-Ins and Add-Ins, LabVIEW cannot be used to create such a product because LabVIEW cannot inherit from and implement the IDispatcher interface.

 

The CLI - Common Language Infrastructure is an open specification developed by Microsoft tha

 

It allows anybody to create a programming language that creates fully compliant .NET code.  There are 3rd parties that have created products such as ActivePerl and ActivePython, which allow developers to use Perl and Python (and even COBOL!) to create .NET compliant code.  My vision is for LabVIEW to do the same, so that now every single organization in the world that uses any .NET language can also consider using LabVIEW, without having to run into many issues along the way.  Only with full .NET compliance will random worldwide organizations consider writing a portion of there software in LabVIEW before hopefully moving entire projects onto LabVIEW!

Message Edited by John80 on 09-03-2009 01:49 PM

Currently, any VIs including .NET code are shown as broken in Labview for OSX.

This is particularly annoying for people working in a cross-platform environment, specially considering that the Mono framework covers a lot of Microsoft's .NET implementation with the added bonus that it works in Linux, Windows and OSX.

 

Please allow users to choose which .NET implementation to use.

When building reusable components I create a set of classes that work together to accomplish some larger goal and put them all in a lvlib.  Sometimes some of those classes are optional--they are not required by the library for it to work but they can make it easier for users to use the library for certain tasks.  These optional classes belong in the same namespace as the library.  One behavior of libraries is that they load all inner libraries.  When the inner library is a class all the class member vis are loaded, which wastes time and consumes resources when the classes aren't needed.

 

My current options are:

- Don't include the classes in the library.  Consequence:  I run a higher risk of name collisions and there's no continuity.

- Put each optional class in its own independent library.  Consequence:  Namespace pollution and a reliance on an arbitrary convention to figure out what libraries should be used together.

- Put the optional classes in the library.  Consequence:  Resources are used needlessly.

 

Usually I do the last option as it provides a more cohesive user experience.  I wish I didn't have to.  An lvlib is a functional grouping of code.  A namespace is a logical grouping of code.

 

To be explicit, I would like to be able to define namespaces for each library such that:

- I can have a single namespace that crosses multiple lvlibs.

- I can have multiple namespaces within an lvlib.

- I can add libraries to a namespace without rebuilding all the libraries in the namespace.

- Loading a component with a specific namespace doesn't automatically load all sub-namespaces.

 

Futher,

- I'm not requesting the ability to separate a single class into multiple namespaces, nor do I think that's a good idea.

- I don't mind the class name being part of the fully qualified namespace.

 

To be able to use 3rd party version control tools such as Git effectively, you need to be able to have a program that merges files and can compare files. Unfortunately LVdiff and LVmerge are only available in the professional labview version, but being able to use a VC system of your choice is such a basic need that it should be available for everyone. That way  you would be able to use the basic VC features, better integration with labview could still be integrated in the professional package.

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.

I would like to expose the "Replace With..." method in the LabVIEW Project Right Click Popup menu via VI Server/Scripting.

This would allow e.g. a developer to update the LabVIEW Project after a SCC Rename transaction and preserve all linking. 

Currently this is unavailable.

 

17225iD565D229419523A1

 

In fact I would like a lot more exposed, see here, but Antoine and I agree this was more important and may have more chance of happening quicker?

Now that .NET 4 is out and people are using it to program, LabVIEW should support the .NET 4 framework. LabVIEW needs to stay on top of the game and make it easy to use all the latest technology. Especially something as widely adopted as .NET.

 

Currently, no version of LabVIEW (released or in Beta) supports .NET 4.

Currently, the version of the packed project library (PPL, extension .lvlibp) is defined by the build script which creates the lvlibp.

It would be nice to have an option there to "hook" the version of the lvlibp to the version of the lvlib, which is used for the PPL.

 

Build Settings Version.PNG

 

The advantage is to match the developement version of the lvlib to the deployed version, the PPL.

It would be great to be able to configure LVMerge options via the command line as described here

 

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

 

There was a previous proposal to fix this that was closed

https://forums.ni.com/t5/LabVIEW-Idea-Exchange/LVMerge-Configurable-Load-Options/idi-p/1282252

 

 

Please kudos this so that that it is considered 😉