Continually Update a Pop-up Dialog With the Latest Value of a Variable in TestStand

If your goal is simply to monitor the value of a File Global at run time for debugging within the Sequence Editor, you typically don’t need a pop‑up. You can use any of the methods described in the KB Monitor a Variable at Run‑Time in TestStand which provide smoother, non-intrusive ways to observe live data.

However, if displaying a pop‑up window is a strict requirement, the recommended approach is to implement it through a code module, where you have full control over the UI and can update it dynamically.

In this KB, we present an approach that works consistently across multiple languages supported by TestStand. We explain the overall concept and provide downloadable example implementations so you can try them directly in your own environment.

How this works

The strategy consists of launching the pop-up dialog in new thread. To do that, a Launch Dialog subsequence contains an action step that will execute the Show Modal Dialog Action step, which loads the GUI and brings it to front. The code module for this step requires the following inputs:

• Sequence Context (e.g., ThisContext) - We use this to access the TestStand API and read the variables.
• The lookup string of the variable you want to monitor (e.g., "FileGlobals.MyVar")
• The lookup string of a boolean FileGlobal we're going to use to stop the pop-up (e.g., "FileGlobals.Stop")
• (Optional) A poll interval in (ms)

This is what it looks like if you usec a LabVIEW module:

This is what it looks like if you used a Python module:

What is happening in the MainSequence?

This is the code in the MainSequence:

• In the Setup group, the Launch Dialog sequence call is set to run the sequence in a new thread.
  • This will make the pop-up show up on screen
• In The Main group, the test code runs and updates the variable.
  • This makes the FileGlobal variable update on the pop-up dialog.
• In the Cleanup group, the FileGlobals.Stop variable is set to True.
  • This makes the pop-up close.

The diagram below represents the execution the different threads of this example:

 

The Code Module Implementation

Regardless of the language you're using, the core functionality of the module consists of using the TestStand API to monitor both your variable of interest (e.g., FileGlobals.MyVar) and the stop flag variable (e.g., FileGlobals.Stop). You could also use the TestStand helper VIs, functions, classes, etc to make sure the dialog is modal to Teststand. 

Here is what a LabVIEW code module would look like:

In this example VI, we use the timeout of the event structure to time the variable poll, and also to gracefully stop the VI when the panel closes.

After running the sequence, this is what you should see:

Step-by-Step Guide: Downloading and Running the Example Sequences

1. Download the Update Pop-up at Run-Time.zip file.
   1. This ZIP contains the complete example with code modules implemented in multiple languages.
2. Extract the contents of the ZIP file. 
   1. You will see separate subfolders for the supported languages:
      1. LabVIEW
      2. LabWindows/CVI
      3. .NET
      4. Python
3. Open the subfolder for the language you want to use.  
   1. Inside each, you will find:
      1. TestSequence.seq — the main example sequence
      2. README.md — detailed, language-specific instructions
      3. Pop-up dialog code
      4. Supporting files
4. Open TestSequence.seq in TestStand.
5. An About this example pop-up will appear, explaining:
   1. The purpose of the example
   2. Required software components
      1. Verify that all required components are installed to avoid unexpected errors.
6. Locate and run the MainSequence.  
   7. A pop‑up dialog will appear at run time, updating dynamically with the value of the File Global variable.

Next Steps

These examples can be modified to meet your needs. You might want to replace the numeric indicator with a chart, progress bar, or pass different data types. Feel free to explore the source codes and understand how they work.