LabVIEW Idea Exchange

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

Since the increasing functionality of the project window (libraries, LVOOP, Shared Variables, SCC, ...) it would be nice if it was possible (natively)

to dock the Project window to a side of the screen (something like the google sidebar) and keep it always on top of the VI's.

 

It would speed up development because you have the project window always handy. 

 

Tom 

 

Custom probes are great, however unlike the default probes you do not always have them with you...so why not just make the default probes just a tad smarter? 

 

- The array probe e.g. should not just show a single cell - it should by default show at least some of them (1*10 for 1D, 10*10 if 2D etc. e.g.), have it's scrollbars visible and be resizable?

 You could add some core information about the array, like it's size e.g. in an indicator on the top as well....and perhaps have a pull-down menu for the display format. Keep it general and simple of course, but a bit more convenient than today's probe.

 

 

- The string probe should also be resizable and have a control that let's you switch the display format.

 

- etc.

 

 

The property node has two major advantage over LVOOP - it allows placing a lot of function calls in a horizontally limited space and it uses text, which is MUCH clearer than small icons (IMO) for something like this. It would be nice if LVOOP had support for this as well.

 

The implementation I'm thinking of is basically having VIs which will be marked as property VIs (similar to what XControls have) and will only be allowed to have a single input (or output) other than the class and error I/O. These will appear in the list when you connect an LVOOP object to a property node (ideally with the properties from the parents as well), somewhat like this:

 

Property VIs.png

 

 

When you run the code in this image, LV will run the VIs sequentially, passing the object and error I/O from one VI to the next.

 

 

I know that NI already tried to do this in the past, but didn't finish it. Hopefully, enough support here will encourage them to pick it up again.

LabVIEW classes are how you create new data types in LabVIEW. But part of being a new LV data type is having a front panel representation. Although users can write XControls for displaying their classes, and they can put those XControls in the palettes, whenever a user of their class chooses "Create Control" or "Create Indicator" for the LabVIEW class terminal, they get the cube display. In order to really add a new data type to LabVIEW that behaves as well as, for example, the Timestampp or the Waveform, there needs to be some way to associate a class with an XControl and say, "This particular XControl should be used as this class' default control/indicator whenever one needs to be built."  (To prevent infinite recursion and load dependency problems, whenever you did Create Control/Indicator on a member VI of the class, users would still get the cube control/indicator.)

I think structures should have a better label system. Currently I use free labels of the same color as the loop which looks great and makes the code easy to read and debug. But if I resize my loop I have to manually resize the label as well. I think this should be built into a right-click option.

 

(structure) rick-click » visible items » Structure label

 

Integrated Structure Labels.PNG

It would be useful fo have a built-in mechanism for protecting executable code.  Essentially something similar to what labview uses to protect its own code.  When an executable is run (if this option is selected in the build) the registry is checked for a licence key, the key will compare the hardware id (could even look at max for serial numbers) and key and see if it decodes to the selected seed specified durring the build process.  If the key is not a match the user can not use the program.  Although this is not all that difficult to add, implemented it into the build only would keep for extra code in the source and spending time to protect your IP.  I have been asked many times for this by my clients and hate to have to spend extra time building this feature into my applications.

 

Summary:

Builds have Licence tab.  Includes a private key, enable liscence on exe, liscence expiration (optional), Custom Licence  message(optional ie: "please contact xyz123.com for a liscence number HardwareID=111112345")

If enabled, the licence key (stored in registry or appdata file) is checked.

If key is valid continue loading exe, else prompt for licence key to be entered with custom message.

 

If LabView is to be used as an endproduct with 1000's of distributed copies of your application, the IP Protection is a must.

 

I know there are many 3rd party products but one specifically integrated into the LV runtime environment would be very cool.

 

\

 

 

It would be nice to have bookmarks (possibly based within the project) so that you could quickly jump to certain areas of your code that has to be modified or reviewed frequently.  Obviously, things like state machines are self documenting, but it would still be great if you could quick jump to certain areas.  Being project based, you could also jump to any bookmark in a subvi.

 

bookmk_menu.PNGbookmk_diagram.PNG

Currently, when you use the Reshape Array primitive, if new elements are created, they are filled with the default data of the datatype. Alternatively, allow a terminal that defines the fill value.

 

CurrentReshapeArray.png

CVI has Notify an option in Range Checking; I’d like to see LabVIEW to offer such option in Response to value outside limits.

-Coerce

-Ignore

-Notify

 Add a printer selection dialog (option) for the print VI functionality (yes I know there are ActiveX alternatives etc. but this should definitely be included "out of the box").

The convolution tools have polymorphic instances for 1D and 2D data.

 

The 2D instances have a very useful input to control the output size (full, size X, compact).

 

The 1D instances don't have this input (Why?!). In the vast majority of my 1D convolution applications, I would prefer a "size x" behavior for the output, making the output size identical to the input spectrum, no matter the size of the convolution kernel. If the 1D convolutions would accept this option, performance and inplaceness could possibly be optimized compared to a manual trimming later.

 

altenbach_0-1702743177185.png

 

 

Suggestion:

All convolution instances need an "output size" input, not just the 2D versions.

For some reason, the conversion bullet for fixed point (FXP) does not accept array inputs, so if we have array data, we currently need to wrap FOR loops around it.

 

 Suggestion: Allow array inputs for "to FXP" to make it consistent will all other conversion bullets.

 

(see also this post for an applied example).

The current behaviour of scrollbars on multicolumn listboxes etc. is that they either show the scrollbar or not - however if there is no scrolling necessary they are greyed out.

 

In most non-LV applications this is not the case; there the scrollbars will hide if they are not needed. Such behaviour can of course be achieved programmatically, however it would be nice if it was coded into the scrollbars.

When I have an array of clusters and I want to locate the array index where a specific element of the cluster has a certain value, I need to first build an array from the Array of Clusters and then search that to find the Array element I want:

 code example.jpg

 

It would be nice (and cleaner and likely faster) if I could wire the Array of Clusters into an unbundle by name function and select String[] to get the array of string element to search.

In addition, if the cluster contained nested clusters, I could access them the same way, using the dot notation alrerady supported.  For example, the unbundle would let me select 'cluster1.subcluster2.String[]' to access the subarray of an element.

 

code example2.jpg 

 

I would love to be able to show a ruler on the front panel....when turned on it should float above the objects on the panel...not unlike a cursor with lines in both planes if the panel was a graph. Unlike the grid this would make it simple to align e.g. columns when you have multiple tables underneath eachother. You could of course have this on the diagram as well, but the main use for such accuracy is on the front panel.

 

There are thirds party tools that do this, but it seems more natural to have it available in LV when we already have a grid that only solves a part of the alignment challenge.

In the current implementation, charts increment along the x-axis and waveform graphs have the array index linked to the x-axis. The y axis is graphing the values.

 

There are many scenarios where this axis association should be swapped. However, we cannot do it without resorting to xy-graphs and jumping through flaming hoops, significantly complicating the data structures.

 

I propose a right-click option "swap axes" which would have the following effect, depending on the object:

 

Charts (waveform, intensity) would have the y-axis labeled "time" (by default), there would be an optional vertical scroll bar, and the data would run up (or down) with time (instead of left or right). Everything else would stay the same, same datatypes, data structures, same definition of chart history, etc.

 

Waveform graphs would have the y-axis tied to the array index of the data, while the value is tied to the x-axis.

 

Often, we want the data simplicity of a waveform graph, but swapped axes. One (of many) example application would be an intensity graph with a cursor flanked by a narrow vertical graph on the right and a narrow horizontal graph below (See image). These two additional graphs are used here to interactively show the intensity profile along the cursor lines.

 

 

Currently, it is not possible to use a waveform graph for the graph on the right. We need to use an xy-graph and do some data gymnastics. With this idea implemented, we could use a plain waveform graph with swapped axes and simply graph a plain 1D array sliced out with "index array". Wouldn't that be great?! 😄

 

Similarly, we could also allow this for xy graphs where it is not as important, but would simply swap the way the data is displayed (e.g. the imaginary part along X for complex data). This could be useful too.

 

The ability to swap axes should probably only be available at edit time...

 

 

 

 

 

 

Message Edited by altenbach on 06-24-2009 04:49 PM

Being able to edit the label of newly created VI when called on another VI on the Block Diagram, similar to what is possible with standard VIs (below image).

 

editable label.PNG

The Align, Distribute, Sinzing, and Grouping/Order menus in the tool bar are located in a very inconvenient position, especially when the FP or BD is sized in a way that hides the buttons. Currently if that happens we have to resize the window, select the desired actions, and resize the window back to where it was before.

 

This could be vastly simplified by adding these actions to the context menu if multiple objects are selected. As of LV 8.6 when you select multiple items on the FP or the BD a right-click produces a context menu that simply gives you the option to change Properties. I propose adding to the context menu as follows:

 

Align Objects

Distribute Objects

Resize Objects

Reorder Objects

Group Objects

------------------------

Properties

 

I do know the shortcut keys to redo the last Alignment and the last Distribution but a lot of the times I want to first align some controls left then others top and so on which requiresto reselect the proper method every time.

 

Using "Fit control to pane" and the "Scale Object with Pane" options it is now relatively simple to build front panels that scale the way users are used to from other applications - however there is one shortcoming that it is easy to run into: cases where you want a tab and (some of) the controls (a table e.g.) on it to scale with a pane.

 

Getting the tab to fit and scale is a done deal, but then comes the scaling of the objects on the tab...

 

The option you have today is to fit the controls on the tab to the pane...however that does not give a proper behaviour because then they grow larger than the tab they are on. Objects that are set to fit and scale to the pane should basically use the tab as their "pane" - not the pane the tab is on.

There are some times I'd like to implement changes in a LVOOP hierarchy which requires making many repetitious changes in sibling classes.  Since the sibling classes are similar but not identical, the ability to create ONE sibling class with the new changes and then calculate (and store) the Difference, these Differences could then be applied to ALL siblings essentially batch-editing a whole group of similar VIs.

 

I know scripting can help here but I'm thinking about operations on sometimes quite a lot of VIs and it's simply a question of the return on investment.  Writing a scripting VI to do the changes takes a while......

 

Shane.