I think I am beginning to understand the problem you are having (though it doesn't help me find the problem with your "huge" code). You are largely missing the concept and idea behind the name "Asynchronous Channel Wire". When we call them "Channel Wires", we ignore the most important aspect, that they are (to the best ability we have in implement them) "asynchronous", meaning "not locked to time".
A Tag Channel acts like a Global Variable, and has all the advantages and drawbacks that come with using Global Variables, but with the addition of the "Asynchronous Wire" to show you when/where the "value" is set by writing to a Tag Channel (or writing to a Global), and where the "value" is read by reading from a Tag Channel (or reading a Global). If you've got a Block Diagram that is 5000 pixels high and 5000 pixels wide (as yours is), Globals can be difficult to find, and if you have several of them, telling them apart requires looking at the rather small representation and reading the name associated with it. With a Tag channel, however, you can follow the Channel Wire to see where the Writers and Readers are, and can say "If I put 12345 in this Writer, it will instantly appear in all these Readers".
But there's a problem -- because the Tag Writer (or the code to write something into a Global) may be in a Structure (such as a While Loop or Event Loop) that executes after the Tag-or-Global Reader? Do you see the problem? You'll be able to read something, but it mind not mean anything, it might be the initial Default Value because the code to write the value hadn't yet been executed!
In my decade of using Channel Wires, I don't think I have ever used a Tag Channel (now that I write this, I might have used it once, but it caused me trouble so I had to do some kind of "funny business" to make sure it started correctly).
In LabVIEW, Queues were traditionally used in two main scenarios -- the Producer/Consumer design pattern, and in the Queued Message Handler and Queued State Machine. With the introduction of Channel Wires, the Stream Channel is what you want to use for Producer/Consumer (taking advantage of the "extra inputs" that lets you properly shut down both Producer and Consumer properly), while the Messenger Channel is ideal for Message Handlers and State Machines, as they allow branching and feedback loops.
One last thing I would like to leave with you, which I suspect has a relationship to the extremely large Block Diagram you developed. Think about text-based programming (say, Matlab). The structure of the program is basically one-dimensional -- you start at the top of the page, and work your way down to tne end. A larger, more complex program means you need a very long piece of paper (instead of 8.5 x 11 inches, you need 8.5 x 100 inches). LabVIEW looks like it is two-dimensional, as you can have an Event Loop above a While Producer Loop above a While Consumer Loop, but LabVIEW actually allows you to create three-dimensional programs, such as the Queued (or Channel) Message Handler -- one While Loop surrounds Case Statement, with each "Case" representing a different State of a State Machine (similarly, the Event Loop can handle a dozen events without growing in height or width, it grows in depth). Learn to design your code using Loops around Cases.
Bob Schor
