LabVIEW
VISA&USB and separate window display
@ennng wrote:
Hello Blokk,
Thank you for your advice, I will keep learning and if any one have comment please do so.
The code works fine for me and received data successfully, just I need to add more functionality.
Most of us have probably never used the "low-level" VISA functions that you are using in your code, as we are already using "normal" VISA devices. Kudos to you for venturing into Unknown Territory and getting some success.
However, Blokk is certainly correct that you would benefit greatly from spending the time with the LabVIEW Tutorials and learning some basic concepts, including the Big One, the idea of Data Flow. Let's consider your Loop and see if it makes sense from a Data-Flow perspective:
- Before entering the loop, you open VISA and get a Session Identifier that you bring into the loop after enabling notification of USB Interrupt Events.
- Inside the loop, you wait for an Event, process it, get out an Analog value and a bunch of bits (which you break out as 8 separate Boolean Indicators, instead of the more-compact Array of Booleans).
- You then close the VISA Session, stopping the loop if there is an Error. Let's assume there is no Error, and the loop ends.
- You then do it again, but now the Session Identifier (however that is represented) should be indicating a Session that you just closed! I would expect this to give an immediate error.
In LabVIEW, there is a Data Flow paradigm of Initialize, Utilize, and Finalize (I'm making up cute-sounding names for mnemonic reasons). Initialize refers to the steps you perform to get ready to do a repetitive task, such as acquiring data (plural). Utilize are those steps where you actually acquire (or process), typically done in a loop multiple times until some Stop condition is reached, and Finalize are the "cleanup" steps that you perform to close and put away anything you created during Initialize.
There are two common ways of programming this paradigm -- "Straight-Forward" and "State Machine". The first is similar to your code, but with Finalize moved outside the loop, like this:
,
while the State Machine uses an Enum holding the States (here I named them Initialize, Utilize, and Finalize), a single State Machine Loop, variables passed from State to State via Shift Registers, and a Case Statement, also wired to a Shift Register and "fed" by the Enum designating the "next" state, controlling What Gets Done:
.
Note that in this "view", you don't see the other States, but the Initialize State runs the Initialize sub-VI and puts Utilize on the "Next State" shift register, and Finalize funs the Finalize sub-VI and wires a True constant to the "Stop" tunnel (instead of wiring False for all the other States, I'm using "Use Default if Unwired" to do the same thing).
For this simple example, the State Machine may look "too complicated", but many situations have 5 or more "States", and this paradigm works really well. One example is where you may have a complex Initializion (or Utilization) process that can be simplified by breaking up into several steps (or "States").
So if you spend some time and master some of the Basics, I have no doubt you'll be able to pull off this interesting (and, to my mind, ambitious) Project.
Bob Schor
P.S. -- the last word I wrote reminds me -- do you know about LabVIEW Project and the Project Explorer? If not, look it up, as you should be using it.
