Having a Labview VI as a permanent display on a test run

Question

Using LabView 8 and TestStand 3.5
Currently, the test sequence is composed of 5 sub-sequences.
Each sub-sequences will perform test using some VI and creating success, warning and failures.
Now, I would like each sub-sequences to  call a common vi to update the current progress of  Test count, Success, warning and failures.
The VI is simple, it takes an increment and display the updated number.
However, the current problem is I am unable to have the VI always displayed.
It will quickly flash on the screen when called by TestStand since it has the Show VI when called checked.
But it closes right away.
Is there a way to have a VI always loaded (and displayed)??
Thanks.
EG

Answer 1

Howdy EG -
First, lets address how you are going to send this message from
TestStand.  Obviously, whether using DataSocket or not, you are going to
need to post this information.  I would recommend using the
SequenceFilePostStep engine callback to post the information you are
referencing.  Furthermore, you will need to send a "kill"
message to the asynchronous LabVIEW VI.  You would most likely need to
modify your process model.  This could be as simple as adding a sequence
at the end of your process model execution entry point (Test UUT, SinglePass,
or both).  This sequence could contain a single step which issues the
"kill" command.
To post this information, you could use a LabVIEW VI which posts with
DataSocket, and that may work.  However, using this method, I would
recommend using LabVIEW queues to ensure no data loss.  Additionally,
TestStand also has built in functionality to post messages through the
engine.  The PostUIMessageEx could be used to post asynchronous messages
regarding any information you would like.  You would give each message you
would want to post a different User-code for the message which could be
interpreted by your LabVIEW VI.  You can take a look at the help file
regarding Thread.PostUIMessageEx for more information on posting messages.
On the LabVIEW side, you would have LabVIEW queues to bring in the information
which should work just fine.  Alternatively, with PostUIMessageEx, you
would want a simple interpreter that figures out which message was posted, and
then updates your VI accordingly. 
Tbob was right in that the functionality can be built into your OI instead of
having a separate asynchronous VI.  Usually this would be easier, because
the managers used by the OI already interpret UI messages for us. 
However, since you are going to be dealing with information that you will be
posting through LV
queues or UIMessages, the manager controls would not help here.  Thus, the
option is up to you whether or not to build in the additional functionality
into the OI.
In summary, you can use the asynchronous VI, and post the information using
LabVIEW queues.  I just wanted to make you aware of some of the
alternative functionality built into TestStand .  Also be aware of the fact
that you will most likely need to post the information in an engine callback,
and will also need to post a message to "kill" the asynchronous VI,
most likely within at the end of the process model execution entry points.
Hopefully this answers some of your questions.  Let me know if you need
anything else.
Have a great day!
Regards,
Andrew W || Applications Engineer
National Instruments