NI TestStand Idea Exchange

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

Here are some suggestions to improve the preloading task and reduce debugging expense:

- abort the process at the first unloadable module with keeping the loading window open to get the related module information

- return a list of unloadable modules

- return an error when preloading is not successful

In the first TestStand tutorial,  one suggestion for tracking local variable values is to apply a breakpoint to the code, then step through the execution and observe the variable values on the Variables tab in the Execution window.  One problem I see with this is that with each Step Over in the execution, the focus switches back to the Steps tab.  I have to keep switching back to the Variables tab to see the values.  And this method is taught in the NI tutorial.

 

Perhaps NI can provide a way to lock focus on one of the tabs, in this case Variables, as we step through the execution (such as when debugging code).  Maybe allow the user to jump to another view manually, but then set the focus such as when the next Step is requested, the view automatically jumps back to the view that was set in focus lock.  This would make such a method truly helpful when debugging a TestStand sequence.

For our test we use 48 TestSockets in a Batch process model.

Every TestSocket will gather data for every millisecond while the test of maximal 3 minutes is preformed. A few times per second we like to call a LabVIEW VI and preform some tests on the last few seconds of this data. To give the CPU some time to do other things a 100msec wait time is in between all the tests. While LabVIEW only needs the last few seconds of the array to preform the test, TestStand will take a subset of the array and give this to LabVIEW. But this subset it already taken more than 1.5 seconds in TestStand.

 

Attached is a small Benchmark test that shows (and hopefully explain) this behaviour.

We just make an local array of 180000 data points. (3 minutes with 1msec sample rate)

A for loop of 100 times is done to average the results.

In the loop two VI's are called.

  • One with 100msec wait.
  • The second to receive the array. In LabVIEW the array isn't touched.

 

If we just start with an array from 10000 data points. (the first 10 seconds)

This will take 107.5 msec and about 12.5% of my CPU resources.

Seems good, but the data grows to about 3 minutes, lets test 180000 data points.

This will take 138.5 msec and about 40% of my CPU resources.

We already use 40% of my CPU without doing anything more than give LabVIEW the data.

 

As we don't need the complete data array, it seems not smart to copy everything to LabVIEW. TestStand is capable to take a subset from the numeric array and send this part to LabVIEW.

So if we want to analyse the last 5 seconds, we give the data to LabVIEW like this:

Locals.Array[175000 .. ]

This is only half of the data as the first test, so expected it will be about same in execution speed.

The average execution is now 1.6 seconds, so 1.5 seconds is used for the array subset.

Also the CPU is fully taken by this process. This way our application can't work.

 

As a workaround I send in the complete array into LabVIEW and take a subset in there. This is at the moment faster than take a subset in TestStand, but I would expect that this process can be faster done inside TestStand.

 

I would like to post the idea of an optimized array subset function.

This will optimize the performance of TestStand greatly while working with larger array's.

Especially if you have more TestSockets than CPU cores, like me.

Hi,

 

Recently I wanted to iterate through ALL my subproperties in the container.

 

I've discovered that the function GetNthSubPropertyName accessing only first level of subproperties and it doesn't get deeper into hierarchy.

 

I wonder if it could be an extension to this function - and to all similar functions - allowing iterating automatically over ALL subproperties. For example a new option could be applied here.

 

Recently I've discovered misleading TestStand behavior.

 

In the case where in the sequence we have two steps with the same name and we'd like to refer to the SECOND step via its name like shown below:

 

screen02.png

 

TestStand allows us to do this, but during the execution, this reference is bind to the FIRST instance of the step:

 

screen01.png

 

In this caseTest D should fail showing result 12 not 10.

 

So, TS allows me to pick a step I want, however it looks like TS binds it to the first match on the list; so it is a lie.

 

In my opinion TS should either:

--don't let me do this, or

--implicitly bind it using unique step ID.

 

Anyway the current behavior (TS2014) is ambiguos and shall be treated as a bug.

Hi,

 

As in subject: allow the *.llbs, build as the Source Distributions in LV Application Builder, to work  with TestStand as indemendent application instances.

 

K.

Hello,

 

I have a sequence which must loop a very long time, with cyclic access to hardware components.

In order to limit the amount of memory used by my application i decide to use the famous "Disable result recording" flag.

 

Beside this problem, my sequence don't have to collapse in case of runtime error (Due to hardware manipulations during execution),

and operators don't have to aknowledge the "error dialog box" ... every time an error occurs !

 

To handle my runtime errors, i deceide to :

 

  • The main sequence is a loop calling the different fonctionnalities by sequence calls 
  • I configure the sequence calls with "ignore RTE", so my mainSequence never stops on runtime error 
  • I Configure the "runtime error handling" with the Run cleanup ... so no popup disturbs the operator

This is OK, but i also want to treat my errors (Tracing at least) ... and then i get the folowing problem ...

 

  • The errors are no more accessible using Runstate.previousStep.result.error... ... Runstate.sequence.main.... .... , because i have used the "Disable result recording" flag.
  • Storing a runtime error in locals is not possible in post expressions ... because post expressions are not executing after a runtime error

Perhaps the only way to handle my problem would be to use the SequenceFilePostStepRuntimeError callback ... 

But doing so, would need to use stationGlobals or FilesGlobals to get back the error in my main sequence. (A complicate architecture only to get an error !)

 

So, it would be nice, to be abble to ...

 

  • Let the result recording working
  • This make the runstate.previousstep.result.error... works fine
  • And sometimes, be abble to flush the result tree (Using a new API function. Something like <Execution>.FlushResults( ....) )

PS : My sequence don't use any report, database writing ... thats why disabling results recording is possible !

 

I don't know if i am clear ? (And with my bad english ???) Smiley Frustrated

 

Manu.

Hi,

 

Default log option for " Numeric Array - Graph" , String Array - Array but not formatted properly. Will be good if theres a option to display as table.

 

TS - Array.PNG

This would be a useful feature to recover from a unreposive code module. Particularly useful, if the code module communicates with the firmware inside the DUT which could become unresponsive due to unforeseen erronous conditions.

 

This option should be optiional. It should be configurable with different timeout values. Once set and configured, then TestStand shall stop executing the code module, return from it and generate an error.

Hi,

 

Sometimes I can find difficult to access arrays using indexes. Although straightforward it can be difficult to maintain in certain situations, like calibration data for a lot of frequencies. Lets imagine you have a table of sixty calibration factors per frequency and forty frequencies, generated by third party software to the excel file.

 

It would improve accessibility if we could name columns and rows and use their names instead/along with the indexes.

 

We can access the array data like AnArray[4][6] now. In this idea we could access the data like that: AnArray["63dB”]["125MHz"].

 

When we would like to import the data using property loader it would be easier to access the data with defined names of colums and rows rather than indexes. (data binding)

Hi,

 

Firstly, I've discussed the topic how to programatically disable assesing results here.

 

I've realised there is no such option. Only one alternative is to swich the comparison type to LOG going thru the steps one-by -one.

 

It would be good to have the override method not to compare ALLresults in the sequence (during execution).

Hi,

 

It'd be good if we can see the results come from multiple test limits display as we can see the result comes from single limit display.

 

For example during the runtime for numeric single limit test we see {111.12} in the execution tab.

 

It'd be good if for multiple numeric limit test we could see for example: {11.13, -12.6, 1234.445}. Now nothing is displayed.

It would be great if the default behaviour of the execution view (in both sequence editor and OI) would be to clear the status result of steps contained within a standard looping structure

 

See this discussion for details

 

http://forums.ni.com/t5/NI-TestStand/Is-there-a-way-to-reset-displayed-Step-Status-for-successive/m-p/1651406#M33854

 

 

Now when property loader loads the data from excel files immediately, not waiting for the cell to refresh.

 

It can lead the obsolete value to be loaded.

Hi,

 

Now the Evaluate() command cannot resolve names when the name to evaluate is within the square brackets []. In other words if the name to resolve is a part of the index.

 

It would be demanded the Evaluate() doesn't have this limitation.  

Hi,

 

When you cancel the breakpoint set in the sequence file tab whilst this sequence file is running you can still see it in the execution view.

 

It's bit confusing, and needs correcting, I think.

Sometimes in the tests we would like to check are they any common elements for two arrays.

 

TS2013 have a nice function called Contains() using which devs can easly check if the searched element is in the array or not.

 

And what about the function which returns an array of common elements of two even more than two arrays?

 

Instaed of looping one array and issuing Contains() command it would be good to have a kind of logical AND using which we can have a list of common elements?

 

Would the operator overloading be the right things to do?

 

Hi,

 

I propose to that the steps to have new feature called AllowableCallers.

 

Using this feature developers could restrict the callers (subsequences) from where the particular steps could be called.

 

Having this feature developers could prevent the mistakes of unintentional step copying during creating new subsequences using the copy-paste method.

 

The default value for this settings would be AllowAllCallers, but developer would be able to define the condition as they wish (function window f(x))

Hi,

 

Exactly as in subject.

 

When code modules containing termination monitors receive the terminate signal, the arrow still pointing at them eventhough the current action is one of the action from the clean group.

 

It'd be good if the developers and operators could see the current operation as it is in real, not the last active from before termination.

 

Example:

 

Capture5.PNG

To restore a Teststand perspective to its original layout.