The reasons for using the DSC include this exact situation.
The DSC, with regards to getting data from Field Point modules (the equivalent of PLCs, I guess) runs on a server level, below LabVIEW, called the Tag Engine. The Tag Engine updates a historical database called the Citadel database. This keeps a running track of your data (depending upon the configuration.)
Where the DSC is valuable is that the data server and database are already written for you, and all you have to do is retrieve the data as needed.
In trying to simplify things by not using the DSC, you have tasked yourself with the rudimentary programming involved in retrieving and storing the data from the PLCs, and making it easily accessible by our HMI.
As is sounds as though you have already done the work to create the engine, you are now stuck with how to get your data from the engine to the HMI, something that the Tag VIs do in LabVIEW. You now have to mimic the Tag VIs somehow.
So, on to the real answer to your question (the above was presented for purely information purposes to possibly influence your decision next time...let NI do the work for you...)
I strongly recommend AGAINST both references and globals. References are intended as a way to automate the updating of front panel controls and indicators, and not as a substitute for pointers and references. Globals are just a mess, and I avoid them at all costs. Consider a few options. Your choice should be dependent upon your exact situation.
1. Simple Data Point server. This simple 'server' makes the latest data point available. It stores it in a LabVIEW 2 style global (something I like to call a data object, but which is probably not the best name for it.) Basically, you take the data from your engine, and write it to a subVI that uses an unitialized shift register to store the data. The subVI is always WRITTEN by the engine. Your HMI then READs the data. There is no time or latest data dependency, and simply put, your HMI will always be reading the latest data available. You can find a design template for this in the "Programming Designs..." topic on the main page of the web interface Developer Exchange, LabVIEW General.
2. FIFO, LIFO, or similar buffer. If you need every datapoint to be handed from your engine to the HMI, then you need to buffer the data. Just use the design model as the simple server, but instead of updating the shift register with a single point, you need to append an array for each write, and delete an element for each read. FIFO (First in First Out) buffers remove the oldest data point first, and LIFO's remove the newest on first.
There are probably other methods available. If these two don't fit your needs, please post again. Also, if you have trouble with the design pattern, please let me know. I created that design pattern, and it should be adequately documented, but if not, feel free to poke and prod.
Good luck
-Mike Du'Lyea
