Event structure - general

hello
this is probably something that had been treated millions times, however i could not find direct answers from previous threads on that, so i ask directly.
i am a bit confused by the utilisation of event structures:
first, one would expect that if the event is used, say in a while loop, then outgoing data would be kept trough the sequence, without having to wire trough the other events, unlike as depicted in the pic below. that should be to my understanding the definition of "use default values" on the outgoing data nodes.
however it seems not to work like that. why? is there a way to force LV to do as i want (instead of "use default values", make him "use last input value")?
wiring trough all the nodes make the event structures very unelegant.
second: this is probably a very naive one, but i dont like the way i do it: in some events i have same operations going on as on turn on of the vi. in other words, when i initialise my system, i pass trough several operations, which also exist in the event structure. to make the diagram more elegant it would be usefull to call all those events programmatically a first time. up to now i do it by programatically signalling the values of some controls. however there must be a more elegant way, where i could just queue the events needed. any suggestions?
Message Edited by Gabi1 on 05-17-2007 06:11 PM
Message Edited by Gabi1 on 05-17-2007 06:13 PM
... And here's where I keep assorted lengths of wires...
Attachments:
event structure.PNG ‏10 KB

Jarrod S. wrote: 
Triggering events forces a thread swap to the
user interface thread, which can slow down execution. It can also make
a redundant copy of the data that has to get stored in the control
whose value change was triggered, which you might not need. Enqueuing
commands onto a queue does not have these limitations.
 To clarify Jarrod's comment, it's important to note that neither the event structure itself nor dynamic events cause a switch to the User Interface Thread.  Functions inside the event structure (e.g. property nodes, invoke nodes) can cause a switch to the UI Thread when they operate on UI components.
In that discussion, Jason King points out that:
"There is nothing specific about the event
structure that requires the event-handling case to run in the UI
thread.  In fact, there is not any event that will force it to run in
the UI thread"
"Reading from or writing to a front panel terminal or local variable does not cause the diagram to run in the UI thread."
"Any actual processing of user interaction,
however - either looking at user interaction to determine which events
to generate or finishing processing a filter event after the event
structure has had a chance to discard it or modify any of the event
details - requires the UI thread."
"Pretty much anything you do with the reference to
a control or indicator will cause a switch to the UI thread (property
nodes, invoke nodes, etc)"
Certified LabVIEW Architect
Wait for Flag / Set Flag
Separate Views from Implementation for Strict Type Defs

Similar Messages

  • IPhoto export of events structure

    I have been trying to export my current iPhoto structure (events, places, faces, etc...) from my laptop to my iMac but every action I tried just separate all the pictures out of the evenet. and when I try to import back it just add all the pictures randomly without structure and also congest my photo stream adding all of them there...it's very messy. does anyone have any suggestion on a proper procedure to follow to export the event structure from iPhoto on 1 mac to iPhoto in another mac?
    I have already read most of the posts and nothing worked properly.
    thanks for helping guys.
    SMM

    To move a Library:
    To move an iPhoto Library to a new machine:
    Link the two Macs together: there are several ways to do this: Wireless Network,Firewire Target Disk Mode, Ethernet, or even just copy the Library to an external HD and then on to the new machine...
    But however you do choose to link the two machines...
    Simply copy the iPhoto Library from the Pictures Folder on the old Machine to the Pictures Folder on the new Machine.
    Then launch iPhoto. That's it.
    This moves photos, events, albums, books, keywords, slideshows and everything else.
    What do you mean by "Sync".
    The general term means when two Libraries (A and B) are compared and files in Library A are copied to Library B, while files in Library B are also copied to Library A so that both Libraries are identical.
    This is bi-directional copying and you cannot do this automatically with iPhoto. No Syncing software is capable of parsing the iPhoto Library in this manner. One or both of your Libraries will be damaged if you try this.
    You can have uni-directional copying - files in Library A are copied to Library B - this is essentially backing up. Obviously you can also copy from Library B to Library A.
    The nearest you can get to syncing is to use iPhoto Library Manager to move files/Albums/Events plus associated metadata between Libraries. This process cannot be automated.

  • Event Structure Question

    Hopefully I can explain this okay....
    I'm using an event structure to control several features in my program and all have worked great.  All of the events in my program are handled via boolean buttons with value changed option.  I have a numeric control in my program that controls integration time.  This changes when the user clicks the up or down arrow or types in a new value.  This control is used and needed to changed the integration time in a couple of different event cases.  However now I'd like to use this numeric control (integration time) to not only change the integration time but also trigger one of the events (in addition to the normal button that I have been using to trigger the event I need to have happen).  (The value of the numeric control when changed also executes a case structure when it is changed in one of the other events.)   
    However when I tried to do this, I ran into some problems.  If I change the numeric control value during one of the events in which I need to use it, and after stopping the event, then another event seems to execute (based on the changing of the numeric control, this event is the same event I ultimately would like to trigger).  Basically I need to stop the numeric control from executing after stopping another event when its value has been changed and only executing when I need it to.  Everything I seem to be doing hasn't been working and I'm just not seeing any type of walk around.  But I need to be able to use the control in various events to change the integration time and also if needed to change it and thus trigger an event (besides using a boolean button to trigger the same event). 
    If needed I can post screen captures or sample code, but my main vi is rather large, so I'd have to cook something up as an  example.
    Any help provided would be much appreciated.   
    Using Labview 7.0 and 2010 SP1 with Windows XP and 7.

    The attached amusing example is an architecture which will work for you.  Read the documentation for details.  It has two components - an event hander and a task handler.  The event handler is the LabVIEW event structure.  The task handler is the queue-based outer loop.  If you need to add data to the tasks defined for the queue, make the queue element a cluster and add a variant to it.
    As a general rule, most UI projects involve getting to the same task through different events, making this the standard design pattern for almost any UI driven program.  You can separate the task handler (consumer) and the event handler (producer), but I have found that the synchronization problems are not worth it.
    I posted 7.0 and 7.1 versions of the code.
    This account is no longer active. Contact ShadesOfGray for current posts and information.
    Attachments:
    LargeGUIApplicationsInLabVIEW_70.zip ‏735 KB
    LargeGUIApplicationsInLabVIEW.zip ‏711 KB

  • Event Structures​-best way to implement this UI?

    I am trying to write a VI to control & read data from 4 different "channels" (each measuring a DUT) at once.  I have written all the VI's for initializing instruments, communicating with the devices (VISA, GPIB), setting bias, reading data, etc...that has all completed. I just need to write the overall program with the user interface to allow the user to control these 4 channels & display the measured data.....as it turns out, this is the tricky part! My head is spinning from trying to figure out how to handle all the possible events.
    Basically for each channel, I want the user to be able to
    -enable/disable it  for measurement (e.g. if  there is no device loaded in Ch.3, we don't want to measure Ch.3..maybe disable/grey everything)
    -set bias conditions (only if channel enabled). Allow user to change bias "in real-time" by increment/decrementing (e.g. incrementing from 5.00 V to 5.01 V, for example).
    -turn biasing on/off (again, only if channel is enabled)
    Also,  I want each channel to display its measured data (e.g current, temperature reading)..every second or so. No graphs or anything fancy (for now! ), just numeric indicator. 
    Honestly, this all sounds so simple but I'm having trouble figuring out the best way to implement this, due to the fact that 1) there are multiple channels needing to be monitored for events  2) large number of user events that could occur (seems like at least 4 per channel - enabling/disabling, turning bias on/off, incrementing/decrementing bias values, etc ), Also the if a channel IS enabled, i want to be continously reading/displaying the data.  What is the best way to handle this? Should i have 4 separate while loops, each with an event structure to handle events for that particular channel..or will that give me grief somewhre? 
    Also, I have another nagging question. Pretty much all the examples I see re: Event Structures and booleans involve latched booleans, eg. buttons that are just pressed once and pop back up...e.g. buttons you press to tell it to complete a task (e.g. "Acquire Data" or "Stop") , and once it's pressed it's over and reset.  In my case, some of the booleans would not be latched...e.g. the "Enable Ch.2" button would be 'TRUE" as long as i want Ch. 2 to be read....does that make sense? Then, say hours later,  if i did want to disable that channel,  i would change it to "FALSE" and while that would be an "value change", the new value would not be "TRUE"..does that make sense? So  not sure if that would be dealt with the same way in an Event Structure. 
    Hope this all makes sense and many thanks in advance for any help!!!

    You're halfway there. I'd say the best solution is a producer/consumer structure, the event structure is used to generate queued commands to the consumer loop.
    All data is handled in the consumer loop, where you among other things have an array of clusters of channel/instrument settings. (I usually have several cluster, one for test data, one for instrument settings, one for general settings and so on)
    The event structure can have a 1 sec timeout, in which you queue up a Measure command.
    In the consumer, in the measure state you loop through your instruments and if enabled you measure them and update their indicators.
    The general (smart) way to setup the queue is with a cluster containing 2 elements, a typedef'd Command and a variant.
    This way you can send data with the command in any form which is then interpreted in the consumer.
    If, e.g. you press the Enable button on a channel, you can enqueue Enable and the channel number.
    /Y
    LabVIEW 8.2 - 2014
    "Only dead fish swim downstream" - "My life for Kudos!" - "Dumb people repeat old mistakes - smart ones create new ones."
    G# - Free award winning reference based OOP for LV

  • User event or event structure time-out

    Hi,
    I have two VIs one is a producer, one consumer.
    The consumer VI is called programatically (i.e. not wired) when the producer VI is run
    Both have user interfaces using an event structure.
    I have a control on the producer that i wish to use to trigger an event in/pass a value to the consumer VI. I have implemented this in two ways, but am not sure which is the 'preffered solution'.
    Solution 1:
    Detect  control activation in the producer VI using event structure, load new value in to a global variable.
    Use the time out event case in the consumer VI to load the value from the global variable.
    Solution 2:
    Set up a user event in the producer VI, load the Event Registration Refnum in to a global variable, use the event structure to create a new event when the control value is changed by the user.
    Use  Event Registration Refnum global variable in the consumer VI to trigger the event structure (loaded once, when the VI is first loaded).
    Solution two means the time-out event case does not need to be active, meaning the consumer VI will be doing nothing except waiting for either the user event, or direct user interaction. It will also not have the potential time delay of up to 1 x the time-out value of the event structure. It does require a sequenced start of each VI for the Event Registration Refnum to be loaded in to the global variable before the global variable is read by the consumer VI.
    My end application will be utilising a number of consumer VIs and will require user interaction information from the producer to be passed to them. Which proposed structure would be the generally accepted better practice? 
    ...or if i've missed the best solution, where should i be looking? 
    Thanks,
    Blue 
    (xp, LV 8.6) 

    Example of Queue based function Globals.To store the events and data.
    http://forums.ni.com/ni/board/message?board.id=170&message.id=240328#M240328
    Balaji PK (CLA)
    Ever tried. Ever failed. No matter. Try again. Fail again. Fail better
    Don't forget Kudos for Good Answers, and Mark a solution if your problem is solved.
    Attachments:
    AI Queue.vi ‏30 KB
    DAQmx AI.vi ‏59 KB

  • Extent of Coding inside Event Structure cases

    Hi all
    I am trying to understand the practices while using an Event Structure. I am used to developing most of my projects using an Event driven State Machine Architecture. Most times, I use Event driven-Queued State Machines. I have also used Producer Consumer Architecture with Event structure driving the producer.
    I have always believed that using lots of code, or lots of sub-vis inside one or more cases of an event structure is not a good practice. I reasoned that it will delay the capture of other events occuring while the current case is still executing. This was one of our points during design review, i.e., to reduce the code inside event strucutre cases to as minimal and necessary as possible. We used clusters/queues/LV2Gs inorder to pass on the required data, which will be processed in the other cases/loops.
    However, I happened to recently come across a couple of very old applications upgraded to LV2011. The applications used an event structure in one of the while loops, with one or more parallel while loops inside the Main VI. The event structure was the only code in this while loop, no case strucutres.
    These event structures had loads of code in each case, with sub-vis and nested sub-vis, even DLL function calls among them. Thats when I started to look for information on best practices using event structures and about any available details on the extent of coding allowed inside an event strucutre.
    One sub-vi which was called as a dialog box also had its own event structure (ending up as ensted event structures). I have read about nesting event structures and their disadvantages.
    Off course, the code is working and I am not sure if anyone had any execution problems with the applicaiton.
    However, I am wondering about the pros and cons of having the entire code inside event structure. I would have defined that code a nightmare. Its disturbing me to see that code and being unable to make it better.
    To my understanding, I wish to know if there is any definition or rule regarding the amount of code inside an event structure.
    Thank you

    The exception I use is User driven intefaces where every user action must get a response and each change must complete before the next. In those cases an event only implelmentation is generally fine.
    Now if that code does something that takes long enough for the user to question if the program is still alive should at least get a "Busy cursor" OR a progress bar OR an abortable progress bar where the user get s the option to abor out. THe last case may warrent a parallel process to crunch the numbers.
    But please keep in mind the above suggestions apply only to those User only" type things. Applcations that invlove the word "while" will generally get deamons and other common design patterns used to henld the implementation. But now I have drifted to design teory and away from the subject so ...
    Have fun!
    Ben
    Ben Rayner
    I am currently active on.. MainStream Preppers
    Rayner's Ridge is under construction

  • How to control the event structure

    What i am trying to do is when the condtion is true, i want the event structure to excute. But event structure wil not excute unless there the puch pattern changed, any idea how to do that ? 
    Solved!
    Go to Solution.
    Attachments:
    Try.vi ‏95 KB

    It's more likely he wants the sequence of events he has put together to run after the result changes once.  If you change the logic to check the values after each change of numeric(2), he'll need to learn to check to ensure the last iteration wasn't already true.  Otherwise, he's going to start the sequence over and over.
    Really, you need to get away from the event structure entirely.  It's not what you want.  Your code lends itself to a state machine very well.
    You'll want to ask yourself a few things:
    1) Do I want my code to run continuously or do I just want to check the two numerics once? (your code currently does the second)
    2) Do I want the user to be able to stop my code once the sequence starts? (this is generally a yes)
    3) Do I want Path 6, Path 5, or the comparison to happen first?  Do I want them all to run simultaneously?  Do I need one before another? (currently you cannot predict which will happen first.)
    Topics you'll need to understand are: state machines, data flow, case structures, timing, and race conditions.  Right now, you're looking to get yourself into trouble.

  • Frontpanel freezes when an event of an already closed event structure occurs

    Hello,
    I´d be very glad if someone could explain to me the behaviour of the attached short and simple vi.
    If you press the OK button #1 once and then the OK button #2 the vi finishes, but if you press the first button more than once before pressing the second button, the front panel is locked. In both event structures, the feature "Lock front panel until the event case for this event completes" is enabled. If it is disabled the front panel is not locked after pressing the first button twice. What I do not understad is why if the feature is enabled the front panel locks after pressing the first button twice. I would think that after the loop containing the event structure closes, the event case should definitively be completed.
    Attachments:
    Event.vi ‏12 KB

    This is expected behavior.
    If you look at your event configuration, both events are set to "lock front panel until event completes". If you fire the second event first, the FP locks and you cannot trigger the first event any more.
    Quick and dirty solution: uncheck "lock front panel...".
    Better solution: learn about dataflow and proper program design. What you are doing here is not a good program architecture. Deadlocks, too sequential,  event structures that cannot be serviced immediately due to dataflow dependency, etc.
    Maybe you can tell us in a more general way what you are trying to do.
    LabVIEW Champion . Do more with less code and in less time .

  • Multiple event structures in one VI

    I have two event structures in a single VI, one that handles events that freeze the user interface and one for events that don't. The latter group are all triggered acquisition tasks, where you arm the  data acquisition, but possibly might want to abort it (or do other things, while waiting for the data to come. Obviously you need a stop button to be active and responsive. In retrospect, using two loops was possibly a poor choice, but one I made because it never occured to me that these things would only fire once and have to be put in a while loop to be kept active. No other language does that as far as I know. Anyway, the question is how do I keep both active? Do I enclose both in a single while loop? Do I give each there own while loop. Do I give up and merge the two event structures into one. For clarity I would like to keep them seperate, but that is not essential. I'ld like to know what my options are.
    Solved!
    Go to Solution.

    rossu wrote:
    If they are in sperate while loops will they both run. If they are in one loop will the loop recycle if one structue is still waiting for an event to occur?
    The answer to this is fundamental to how LabVIEW works. A loop will not proceed to the next cycle until everything inside it completes. If you have two event structures in the same loop, both of them need to process an event (or a timeout) before the loop will iterate.
    You can have multiple event structures in the same VI.
    By "freeze the UI," do you mean the "Lock front panel..." checkbox in the event dialog? There is no problem with having some events that do lock the front panel and some that do not in the same event structure. I'm not sure that this is what you mean by "freezing" the UI, though.
    EDIT: and one more comment. Generally you should not put long-running tasks (like data acquisition) inside an event structure. Instead, the event case should pass those tasks off to a separate loop (for example using a queue) so that the event structure can quickly go back to listening for other events.

  • Event Structure/UI Help

    Hello,
    I'm stuck.....I am having some trouble figuring out how to make my attached VI behave as needed. The top level VI "EventStructure.vi" is a front panel UI interface to a label printing app (using ActiveX). When the VI is loaded it sits in the internal while loop until either the Print or Exit front panel buttons are pressed. If the "Select Product" drop down has a value change I would like it to go out to the particular label file for that product and read a Serial Number variable from the label file and report back the serial number to the front panel. I would like to have the VI front panel hold that serial number until there is another value change on "Select Product" but right now it only holds it on the front panel until the next time through the while loop. Also, the string containing the path to the label file only holds in memory until the next time through the while loop where it is cleared. Is there any way to have these values hold in memory and only change when there is a value change on the "Select Product" combo box? I do understand that this behavior is the general way Event Structures work but I am unable to figure out a better way to do this without using an Event Structure. The sub-vi "GetNextSerialNumber" calls an external application using ActiveX and it takes a while (4-5 seconds) for that application to load and process the ActiveX commands so I only want to call the external application when there is a value change on the "Select Product" combo box.    
    Solved!
    Go to Solution.
    Attachments:
    EventStructure.vi ‏32 KB
    ActiveX_Print.vi ‏17 KB
    GetNextSerialNumber.vi ‏16 KB

    You need to store any values you want to retain in shift registers. This will allow you to pass the value from one iteration of the loop to the next.
    Mark Yedinak
    "Does anyone know where the love of God goes when the waves turn the minutes to hours?"
    Wreck of the Edmund Fitzgerald - Gordon Lightfoot

  • Event structure inside a case structure

    Hi,
    I've got a problem w/ my porgram, and managed to boil it down to this
    simple example.  The program basically hangs if you change the
    Numeric value when the boolean is false.  I don't understand
    why.  I suspect it has to do with the way event structures are
    treated, but if someone cou please explain this I'd be greatful.
    Also, now imagine I have 7 numeric controls, handled by 7 cases in that
    event structure, and I actually want to do things in response to the
    value change for each.  Can someone suggest an elegant way to do
    that?  I thought what I had here was a good design, but apparently
    not.
    Bjorn
    (I'm using labview 7.1)
    Attachments:
    EventInCase.vi ‏24 KB

    It is generally a bad idea to place event structures into cases. Events structures need to be able to breathe.
    Maybe you can redesign your program and place the case structure inside the event structure, for example? (Also have a look at the online help for the event structure, especially the link "caveats and recommendations for using events ".)
    Detailed analysis:
    Your event case for the numeric is set to "lock front panel until event completes".  If you change the numeric while the case is false, the evet structure cannot execute, so the front panel locks forever. The observed behavior is as expected. All clear?
    In addition, if the case is false, the main loop spins at nearly infinite rate, consuming all available CPU. Place a small wait to be more cosiderate to everything else running on your rig.
    LabVIEW Champion . Do more with less code and in less time .

  • Acquiring continuous data using an event structure

    I am new to labview, having recently taken the Core I and II courses.
    I am programming a test rig to acquire the linear position of a hydraulic cylinder and plot it over time.  In programming this code, I elected to use an event structure so that when a front panel button is pressed, a certain part of the test is run. 
    In one particular part of the test, called the Snub Test, I need to measure the position of the cylinder over time and plot it to a graph.  The data acquisition needs to be continuous, however the event structure only allows the loop to run once. 
    I have attached a portion of my code for reference.
    Can someone please advise how I can get this data acquisition to run continuously until the user (or a reference trigger) stops the test?
    Thanks
    Attachments:
    Front Panel.vi ‏115 KB

    A few comments to your VI in general:
    You changed the stop button to "switch until released", most likely because you fabricated a race condition and did this as a quick fix. The reason is (1) your placement of the stop terminal outside the event structure and (2) the use of a local variable wired to the stop condition. The button terminal of a latch action boolean belong inside it's associated event case! This way it gets read (and reset to false) when the event occurs. In your case, the local variable and the button get read before the event occurs and the loop needs to spin once more at the event that occurs when you release it (true->false). At this point, the local is still true from the earlier event and the loop stops. Correct would be: latch action, stop terminal inside stop case and wired to the stop condition from inside the event. Other cases use the default output (false) and don't stop the loop.
    Your "equal false" code fragment is just an invert, right? So why complicate things?
    Why do you need a wait if there is an event structure?
    LabVIEW Champion . Do more with less code and in less time .

  • Multiple event structure in a while loop

    Dear All,
                   I had a multiple event structure inside a while loop. The purpose of doing so is because I had a few 2D picture on the front panel. I would like to detect which 2D pictures had been click using the mouse down event structure for 8 of my 2D pictures.
                  The problem that I faced now is that when I of the event case or one of the 2D pictures had been click, it will not exit the while loop. I had to click on all the 8 2D pictures before it will exit the loop.
                  I had uncheck the under the "Edit Event" --> "Lock Front Panel (defer processing of user action) until this event case completes". But I am still stuck inside the loop.
                  Each 2D picture will perform different action therefore I cannot have an event case of all 2D pictures inside else I would know which 2D picture had been click.
                 Is there any other way out of this situation? Pls help. Thanks a lot

    A producer/consumer architecture (look at the examples that ship with LabVIEW) is comprised of two parallel while loops. One loop contains the event structure. The other contains your consumer which is basically a queued state machine. It receives messages from the producer via a queue. Your event structure can register a separate event for each 2D picture control or it can use a single event that would determine which spefic controls was clicked on. This is a more general approach and expands easily. Here is a basic example of what I am talking about.
    Mark Yedinak
    "Does anyone know where the love of God goes when the waves turn the minutes to hours?"
    Wreck of the Edmund Fitzgerald - Gordon Lightfoot
    Attachments:
    Event Producer-Consumer.vi ‏14 KB

  • Event structure with sub-VI

    hi,
    I designed a event-driven state machine UI that uses pop-up sub-VI for user date configuration and COM port config. Calling the sub-VIs works fine, but by closing them and sending back the modified data to the main state machine, the event handling routine stalls. With highlighting, I could verify that after returning from the sub-VI, the timeout event is being carried out as the only one (used because there is some background code to be processed repeatedly).
    There are more buttons on the front panel then handled events in a certain state (the other buttons are used in other states), but the unused buttons are neither disabled nor hidden. Could that cause the problem? Or does the OK button of the closing sub-VI (or the changing data out of it) affect the main state machine event handler?
    Thanks for your reply
    Pac

    Hi, Pac.  Looking at your original VI, I would make a couple of general comments:
    1) I don't suggest using an event structure in a timed loop.  The timed loop is to ensure determinism in the code that is running. This doesn't really fit well with handling user interaction.  As suggested in other posts, I would have a separate loop that is watching for user interaction with an event structure.
    2) Having different event structures in each frame of a case structure is asking for trouble.  The link Jarrod posted should be very helpful, but it is just a subset of the thorough documentation on using event structures (note: I may be a bit biased as I am one of the authors of the documentation .  I would browse this whole chapter (http://zone.ni.com/reference/en-XX/help/371361A-01/TOC20.htm) and pay specific attention to the "Caveats and Recommendations" section which should help save you a lot of frustration.
    J
    Jason King
    LabVIEW R&D
    National Instruments

  • Event Structure in Timed Loop in real time cannot work

    I am a new user for LabVIEW. And I met a problem which really frastre me!!! Hope someone can help me out. Thanks in advance!
    I simply want to use event structure under timed loop, which is extrmely important in my design.
    However, this works very good in my computer (without connect to FPGA).
    Once I connect it to FPGA, then I can run it still but there is no response!
    My file is attached. Please somebody helps me!
    Looking forward to your answers!
    Solved!
    Go to Solution.
    Attachments:
    Test for Timed Loop.vi ‏9 KB

    The FPGA runs headless. Event structures are not going to work. What you need to do is have an application on your host where the user presses a button, changes a value, etc. That event should send a message via TCP/IP to the code running in the real time environment. Then the real time environment should set a control on the FPGA to the value you want.
    In general, real time programming with FPGA has multiple layers.
    1) Host code-> handles user interactions and communicates them to real time code via TCP,UDP, etc. Displays data to user sent from the RT controller.
    2) Real time code->runs headlessly. Handles messages from Host code, processes FPGA data, communicates with FPGA much like the host code communicates with the real time code
    3) FPGA -> does acquistion and passes it via FIFO to the RT
    The first thing you need to do is understand the architecture and how all these pieces of the puzzle work together before throwing things down on a diagram.
    CLA, LabVIEW Versions 2010-2013

Maybe you are looking for