topic Re: Creating 2 separate Main programs, passing values in LabVIEW

Creating 2 separate Main programs, passing values

Newbie217 — Sat, 30 Aug 2008 11:34:34 GMT

Hello,

I am in the process of a creating two sepearte main VI programs. Program (1) will be the program the user interfaces with and updates dynamically (using the front panel to change values, addresses, and states of power supplies, DMM channels, analog I/O, digital I/O, etc). Program(2) will be a separate program running through automated tests (current/voltage sweeps, data acquisition, etc). Normally I would like to incorporate both programs into a single VI, but the shear number of front panel controls and indicators makes it more practical to run separate programs on separate monitors (dual-screen setup). My question is, how do I go about passing the dynamic updates of program (1) into program (2)? For example, if I use event structures for both programs, and change the power supply voltage in program (1), how do I go about updating program (2) with this new value? From what I remember it isn't possible to have a program running and being used as a subVI as well. Any thoughts or recommendations? It would help tremendously to get this type of setup working.

Re: Creating 2 separate Main programs, passing values

Pnt — Sat, 30 Aug 2008 12:09:54 GMT

If I understand correctly...

You can run one exe, one application, with two vis with their front panel open simultaneously.

You can pass the data through them with, functional globals.

Is this what you need ?

Re : Creating 2 separate Main programs, passing values

chilly_charly — Sat, 30 Aug 2008 12:11:42 GMT

I suppose functionnal variables, global variables or shared variables should do the trick. A search on the forums will return hundreds of references on the subject !

Re: Creating 2 separate Main programs, passing values

jjcimon — Sat, 30 Aug 2008 12:15:31 GMT

from what I understand, take a look at shared variables, and on the main vi 1 put a while loop aside from the event structure with the update of

your indicators from the shared variables

Re: Creating 2 separate Main programs, passing values

Newbie217 — Sat, 30 Aug 2008 20:52:58 GMT

Thanks guys! I will go with the shared variable approach. Everything seems to be working right so far... Now, is there a way to lock the front panel of program (1) while program (2) is executing its specified event? Usually with event structures, there is a check box to "lock front panel VI until event case finishes". Is there a way to do this between different programs?

Re: Creating 2 separate Main programs, passing values

Pnt — Mon, 01 Sep 2008 05:16:06 GMT

You can use a simple boolean variable.

When it is set to true you will ignore every front panel activity

Re: Creating 2 separate Main programs, passing values

DFGray — Tue, 02 Sep 2008 13:52:18 GMT

I would strongly recommend you avoid shared variables and globals for this sort of application. Neither are thread-safe and both will cause many problems due to race conditions. You can avoid such problems by using a thread-safe storage mechanism. The most commonly used is the functional global (aka LabVIEW 2 global, shift register global, or action engine). I prefer to use single-element queues, since they are more scalable and work better with object-oriented design techniques. You can find examples and information about both of these techniques on this forum, and both work well.

Let us know if you need more information.

Re: Creating 2 separate Main programs, passing values

Newbie217 — Wed, 03 Sep 2008 00:19:12 GMT

I appreciate the heads up. I'm not exactly sure how to code the functional global as I have never used it before. To better clairfy the type of program I am trying to run, included are the (2) Main VI's I am trying to setup. The files were written with LabVIEW 8.5 and are currently setup using shared variables. How difficult would it be to switch over to functional globals from the code I already have written? Thanks.

Re: Creating 2 separate Main programs, passing values

Newbie217 — Wed, 03 Sep 2008 00:20:01 GMT

Here are the project and shared variable library as well.

Re: Creating 2 separate Main programs, passing values

DFGray — Wed, 03 Sep 2008 13:05:24 GMT

Several things you can do to improve:

You are currently using a simple event structure for program execution flow. You would probably be better off with an event driven, queue based task handler. You can find a paper and example code here. This code also gives an old example of using semaphore locked functional globals. While useful, the semaphores slow them down quite a bit.
Use VI Server to launch one of your main VIs from the other. This should take place in your initialization code. When you launch the second VI, you can pass it references ( e.g. a queue reference to a single-element queue "global" ). This also ensures that your hardware is fully ready by the time the GUI which uses it is launched.
You can find examples of several types of reference objects here. The attached paper will also explain why you want to use single-element queues or action engines instead of globals or shared variables. Use either the single-element queue or action engine approach to store your "global" data.

If you need more information, let us know.

Message Edited by DFGray on 09-03-2008 08:05 AM

Re: Creating 2 separate Main programs, passing values

Newbie217 — Fri, 05 Sep 2008 05:55:43 GMT

Thank you all for the replies and suggestions! I realize I have a long ways to go, and a lot to learn before gaining enough insight to code effectively. Anyway, I am not too familar with using queues, action engines and some of the more advanced LabVIEW functions. I will have to look more into the sample code when I have some time. Meanwhile, I am trying to avoid using shared variables as was suggested. My first attempt to improve the program was to use the Server VI to call my second program from the main program. The current problem I am running into is that I am unable to come up with a clever way to exit the Event Structure of the second program, and still have the front panel of the first program retain its functionality.

What I really liked about the shared variable approach was that I could open (2) VI's independently and execute them. Both programs had Event Structures that waited for user interaction with the front panel, and exchanged/updated the values without affecting each other. When I try to use the Server VI to call my second program, I get stuck inside the event of the second program and cannot regain access to the first program. The way I am getting out now is to wire a True statement to the stop function so that the second program only executes a single time before returning to the main program. The problem now is that the second program is no longer event controlled, but a single execution. Any suggestions on how to best address this problem? The shared variable approach seems to make much more sense at this point...

Re: Creating 2 separate Main programs, passing values

Newbie217 — Fri, 05 Sep 2008 05:56:26 GMT

Also including the (2) programs.

Re: Creating 2 separate Main programs, passing values

DFGray — Fri, 05 Sep 2008 13:52:56 GMT

You got hit with a dataflow problem. Your main VI is waiting for the subVI (your other front panel) to finish before it continues execution. Fortunately, there is an easy way around this issue. Instead of using the Call By Reference Node to launch your second VI, use an Invoke Node and set the method to Run VI. Set Wait Until Done to FALSE and Auto Dispose Ref to TRUE. This launches the VI as an independent thread and returns control to your calling VI.

You need to set your data value before running the VI. Do this with another Invoke Node before running the VI. Use either Ctrl Val.Set [Flat] or Ctrl Val.Set to set front panel controls. Note that this method is not dependent on the connector pane pattern, so is somewhat more maintainable. However, it is slower than the Call By Reference Node method. In cases like this, it really doesn't matter.

I agree that the shared variable is easier to use up front. However, it is not as maintainable in this sort of application as a LV2 global or single-element queue. My experience has been that you either take the development hit up front to use a thread-safe reference object or a much larger debugging hit later, and then need to use the thread-safe reference object anyway. Once you have done it a few times, it is much easier, especially if you make templates of your favorite design patterns.

Re: Creating 2 separate Main programs, passing values

Newbie217 — Fri, 05 Sep 2008 17:21:56 GMT

DFGray,

Thank you so much for all your help. It is much appreciated. I will revise my program and try what you suggested. Hopefully the extra work involved with overcoming the initial learning curve will pay off in the end. Cheers.