LabVIEW Idea Exchange

Post an idea

Like "Search 1D Array in reverse", but for the Threshold 1D Array function.

Also, there should be an option to find the first sample below a threshold.

When you want to find the start and the end of a peak, it's really messy to make code for it:

With these options,

1) Find threshold (set to high)

2) Find threshol (set to low), with start index the result of 1)

Without it you need:

1) Find the srart (only one function)

2) Reverse the array (this does not

3) Negate the array.

4) Negate the threshold

5) Find the threshold (starting from 0 or previous peak).

6) Find the real index (reletive from start)

7) Repeat 5 and 6 (we might have found a peak after the first peak, and we want the end of the first peak).

😎 Stop when the found index is past the start index (and then use the previous index), or when no index is found.

I'll keep the idea as broad as possible. The solution can go a few ways, and I don't want the idea to be turned down, because the solutions.

In general, DVR's have two related issues.

1) DVR's are only usable when initialised.

This makes them more difficult to use for, for instance, interlocking. Instead of using a IPE structure, we have to:

(make a sub vi)

check the ref

if not a ref create a ref

enter the IPE structure

2) DVR data is not persistent.

So a singleton class implemented with a DVR will lose it's data the moment all code is stopped. Debugging a sub VI that uses the class is impossible, because the data is gone. This makes DVR classes much less attractive.

I know how to solve these issues, but I think LV could make this easier.

So the rather broad idea:

Somehow allow DVR's to be sometimes memory persistent.

So the new event inspector is a great tool.

It's engine is the VI "EI Get Event Queue Data". If you open it (it's pw protected) it has a warning that reading it clears the data, so if you read it at two locations, both locations get half the data. The VI also works in executables.

It would open up all kinds of possibilities if this data was available to programmers. One example, audit trails. Debugging as well. To me, that sounds great. A great tool would become a great API.

All this would need is a wrapper around EI Get Event Queue Data. Or even a replacement for EI Get Event Queue Data. Only real problem might be that the used dll needs to be stopped when it's data is not cleared. If not, it will probably keep filling memory until running out of it.

Regards,

Wiebe.

View All (1)

wouldn't it be nice if like a user event...

We could register for queues:

Queues are similar to user events, but have some very usefull properties. Combining queues with event structures always results in parallel loops, and communication between them (with user events, or value signaling events). It would be really neat if we could register queues in dynamic events.

A lot of "sweetness" could be added, but if only the basic idea is possible it whould be powerfull.

When more then one event structure registers for queue events, each element will only be triggering one structure (like dequeueing with the normal queue functions).

Regards,

Wiebe.

View All (6)

The idea comes while developing IMAQdx program which should acquire as much frames as possible from GigE camera (1 Mpix, 100+ fps). This frame rate is higher than computer can process and save it to avi. Utilizing large buffer on memory (16Gb of RAM) and LabVIEW x64 works smoothly, but when the buffer is filled, the acquisition stops while only a fraction of the frames have been processed. We need finite acquisition, but with not known in advance duration.
From the other hand, the images that have been acquired are still in the buffer. It would be nice to have the ability to get the acquired frames from buffer. Another way is to add something like "Pause grab" function which stops filling the buffer not destoying the buffer.

View All (2)

I don't know if this idea has appeared before, but for me it looks interesting enough to be presented even again.

Now the sequence structure takes a lot of place in the block diagram.

Why not utilise modified error wire to impose the flow instead? The modification would be that potential errors transmitted over this wire would be ignored, if a proper option on the error wire (or in VI or in the environment) will be selected; for example: impose flow only or ignore the errors.

I'm aware that the proposition of an option of automated ignoring the errors in error wire doesn't sound good. I agree that there is a good practice that error should be rather displayed and captured quickly than ignored and forgotten. And I'm aware that developers can explicitly break the error wire within the VI which effectively do the job: impose the flow with ignoring errors.

However, the reason of this proposal is to speed up the code development based on the native LV paradigm of the dataflow. It would be much quicker to build the application in quick and dirty style by not introducing the space consuming structures as the sequence structure is (BTW: I'd still recommend to leave the stacked sequence structure) and spending the time dedicated for development and solving real world problems for trying to fit and extend the structure and VIs within and around it.

For me ignoring the errors on the error wire option would be a natural option. Maybe a bit semantic should be involved here as well for better naming and description, but I think the idea is good enough to be presented.

View All (4)

View All (3)

Convolution.vi is could be made much faster.

First, it does not seem to take advantage of the presence of multiple processor cores. Convolution could be parallelized by cutting one input array into pieces and performing the convolution on the different pieces in different cores. It would be nice if the vi did this automatically.

Second, the vi only works on floating point values (doubles). A polymorphic version that used integer arithmetic (using the "direct" method) instead of floating point would be faster when integer arrays are being convolved.

In the properties of a subVI reference, you can get the name and reference of the VI.

When The VI is re-entrant, with this property then you get the name and reference to the "Model" VI but NOT to the Clone associated to the subVI.

In scripting activities, it would be usefull to be able to get the name and/or reference of the Clone VI of an instance subVI...

For example, in development mode, I have a instance subVI of a re-entrant on which I need to put a breakpoint by scripting at runtime for debug purposes. This is something I actually can't do.

I think that's this is something easy and that might already exist (in private properties of subVIs ???) because when you double click on a subVI instance of a re-entrant VI, then the front panel of the clone (i.e. copy) of the original VI is opened. So there's somewhere a link between the subVI (reference) and the Clone VI.

(it's already possible in VI property to get the Clone name when this VI is re-entrant).

(Hope I'm clear...)

View All (5)

I have a question regarding the Soft Front Panels for PXI devices and NI I/O trace application which enables the monitor/capture of commands issued to devices in the PXI rack.

I have been using it to see what commands are issued when a voltage/current/setting is changed in a DC power soft panel for a device i.e. SMU.

It is really handy for that but for one thing, the soft panel “polls” the SMU/DMM continuously which creates a load of query/measure commands on top of the command you actually issue, see attached example.

Unfortunately "NI-DCPower Soft Panel" is designed to poll status of the device by default.
I would like to suggest to have a debug option which disables the polling.

The attached example only contains 3 lines that I actually wanted to see but is filled with extra 'unwanted' data from the polling.

View All (1)

I know breakpoints can be used to speed to sections where codes issues may arise as well as retaining values, etc. However, there are times when it would be helpful to have a speed control on the bulb to speed up and slow down the speed of the code which is running especially whenever evaluating someone else's code or new architecture/projects. This way if I need to step through the code and want to watch it run in the block diagram I can speed up or slow down the pace by which LabVIEW steps through the code. I would like a really slow mode as well as a very fast mode.

When interfacing to a .NET assembly in Labview we use constructor nodes, property nodes and invoke nodes. The application builder allows Labview users to build .NET assemblies but the functionality of these assemblies is limited to using invoke nodes to access method vis. Support for property nodes is missing at present. Labview has invented the concept of accessor vis for accessing class data but these vis are only available to master vis or built applications. My suggestion is that the concept of accessor vis could be extended to provide property node functionality in built .NET assemblies.

Currently, for an array variable, changing an element requires the developer to read the array, update the element and write the array out. Whilst this is fine for simple cases with not sophisticated data flows, it becomes very cumbersome for cases when parallel processing is introduced. For instance, multiple loops updating an array of status flags.

At present, if two loops (which may be in different Vis) both execute a read-update-write operation on a global shared variable, data can be lost if the operations happen at similar times. Consider the following example:

Looking at the image above, let's imagine "array1" consists of two elements with values F and T respectively. Then the operation would happen as follows:

Step Number	Action taken	Array values
1.	Read "array1"	F and T
2.	Read "array1"	F and T
3.	Update "array1" element 0 to T	T and T
4.	Update "array1" element 1 to F	F and F
5.	Write to "array1"	T and T
6.	Write to "array1"	F and F

Hence all the data written by “Loop A” is lost. Putting user-defined locking using shared variables around the operations does not seem to work, presumably due to update rate of the locking variables.

What would be helpful to overcome these race conditions is to replicate the functionality present in other languages to do operations like a[3]=4 or printf(“%lf”,a[4]). In these cases, an atomic operation is performed to get or set the value in the defined memory location. The addition of this functionality to shared variables would be extremely powerful.

An example of such functionality could look something like this:

When comparing strings with the case structure, behavior at the time of the range specification is different from that of numeric type.

I have set a default case to case the other in the block diagram below.
If the default case, "B" is to be output.

You might think that it outputs the "A" none at first glance, but it will be "B" output of the block diagram of the second.

Block diagram

Output

This behavior is described in Help. It was also in the old version. It is probably specification.
It may be the reason for a bug if you write a program of string processing without knowing this specification.

I think that we should match the case, "c", which wrote "a" .. "c" in the case selector label.

Link：LabVIEW2013 Help - Entering Values for Each Case Structure Subdiagram

Quote:

String ranges
A range of a..c includes all strings beginning with a or b, but not c. String ranges are case sensitive. For example, a range of A..c behaves differently than a..c because LabVIEW uses ASCII values to determine a string range.

What do you need our team of experts to assist you with?

Request a quote Find the right product Place an order Get support on a product

How can we help?

Please enter your information below and we'll be intouch soon.

This field is required

Preferred communication method

Email Phone call

What do you need our team of experts to assist you with?

Request a quote Find the right product Place an order Get support on a product

LabVIEW Idea Exchange

threshold array in reverse

Connector Pane (Output): set "This connection is => required"

Persistent DVR 's

event inspector API

register event with queue

Disable item of ENUM if already selected

Exit LabVIEW from RunTime only

IMAQdx buffer availability after acquisition stop

Drop sequence structure and promote to use modified error wires to impose the flow.

Allow Same Quick Drop Short Cuts...

For Loop input and output tunnels

Convolution.vi speed

"CloneName" and/or "Clonereference" property of a subVI reference

Event Case Firing/Executing on an Indicator Value Change

Soft Front Panels automatic polling

Speed control for the bulb

Exposing accessor vis as Properties in a .NET assembly

invoke node/Copy Selection (Diag)

Network Published Shared Variable Array Handling

Behavior when you specify a string range to the case selector label