LabVIEW Queued State Machine as Parellel Process Enabler

Hi
LabVIEWs Queued State Machine Architecture is a detailed article on its application for parallel process programming geared to take advantage of LabVIEWs hyperthreading capabilities and multi-core processor PCs of today.
I am writing future book chapters as blog articles so your critique/comments are appreciated.
Anthony L.

I have really enjoyed the articles on ExpressionFlow. I also like this one, but I think it could use just a little work. I think that the content is good. However, about 1/4 of the way down, you have:
A general layout of QSM-PC architecture comprises of the four objects annotated by the encircled numerals 1 to 4 shown in Figure 1.
These objects are namely: (1) Queue reference object; (2) User events
object (optional for head-less embedded applications that require no
user interaction); (3) Main state machine object; (4) One or more
parallel processes subVI objects.
You then go on to have
Item (1) The Queue Reference
Item (2) Consumer Object State Machine
Item (4) Parallel Process SubVIs
You need to reconcile the two. I think that a separate (probably earlier??) chapter/article on event structures including dynamic (user) events could be referenced as item 2.
Thanks for the articles and I hope that this helps!
Bob Young
Bob Young - Test Engineer - Lapsed Certified LabVIEW Developer
DISTek Integration, Inc. - NI Alliance Member
mailto:[email protected]

Similar Messages

Queued State Machine, not a state machine?

I've been reading up a bit on design patterns that seem popular among LabVIEW users, and I have a question with regards to the design pattern described in the following article:
http://expressionflow.com/2007/10/01/labview-queued-state-machine-architecture/
I don't see how this is a state machine at all. To me it just looks like a producer/consumer pattern for queuing up actions (what is described in the article as states) to be executed in the consumer loop. I don't see where a state machine comes into play, determining state transitions based on current state and inputs, like shown in the following:
http://zone.ni.com/devzone/cda/tut/p/id/3024
Am I completely off?

Yeah exactly.
I was thinking a nice way to implement something QSM-like would be to produce instances of a message handler object that maintains its own state and a message queue. You could produce a new object for network I/O that inherits from the general message handler, one for managing the UI, data aquisition etc. They would communicate in a network by passing messages back and forth to their respective queues and each would be a true implementation of a state machine.
Has to be right up LabVIEW's visual alley
Edit:
Now that I come to think of it, this would be almost exactly what could be done compactly with LabVIEW event handlers and user-generated events.

Double Click Property Node not functioning with Queued State Machine

I am writing an application which relies on input from the operator to start different steps in a process of steps. I am using a queued state machine, however I cannot get the Double-Click property of my listbox to function with in this Queued state machine. I have tried Creating a refrence to the Listbox and creating a property node from that refrence. I have tried a property node of the control. The double click functon works only if the queueing is not occuring. It has something to do with the queue but I am at a loss as to what is causing it. Any help would be GREATLY appreciated. I have attached a simplified version of the state machine with the double click function. Thanks for any help on this. It is written in LV7.1
Attachments:
Test Q.llb ‏55 KB

Hi
Its Simple....
Your Properrty node is not getting read..... dont understand how..
see the attachment...
now laugh at your small mistake... (even i have the habbit of making such small mistakes ;-) )
Message Edited by Tushar Jambhekar on 01-11-2006 11:38 AM
Tushar Jambhekar
[email protected]
Jambhekar Automation Solutions
LabVIEW Consultancy, LabVIEW Training
Rent a LabVIEW Developer, My Blog
Attachments:
Test Q.llb ‏55 KB
Picture.JPG ‏44 KB

Simple State Machine Vs Queued State Machine

Using LV2009 + WIN7+Pentium 4 @ 2.5Ghz with 3 GB RAM.
I have a machine control code inside a 10mS main loop that has 7 ( yes seven ) Queued State Machines ( QSM) and I find the Finished Late boolen keeeps poppping often. Not a very good sign if you ask me.
And the code itself does not have too much of computation or FP activity. But it has four Graphs with one plot on each of them. These are updated once every 10ms. Can slowing this update ( say once every 250ms ? ) help ?
A simple query : In terms of performance overhead, does a QSM demand more than a Simple State Machine ( SSM ) ? Can I avoid the Finished Late warning by switching over to SSM at least in three of the cases out of the seven ?
Thanks
Raghunathan
LV2012 to Automate Hydraulic Test rigs.

I think your question demonstrates my point. Unfortunately, I don't have a good example to point you to and don't have the time to write one. I will try to explain better. Let's take a simple example - a landscape watering controller (sprinkler controller). This controller will have several states (e.g. initializing, waiting, watering, closing). Each of these states will accept several commands, but not all commands are accepted in all states. For example, if the system is watering, a command to start watering could be ignored.
In most programs, at least some states should be interruptible. For example, if it starts to rain, the watering system should stop watering immediately instead of watering for a set length of time. However, if the system is in the initialization state, this will probably not be interruptible (but also short).
As you said, the classic LabVIEW way to implement such a thing is to have a case statement to represent the state, and a case statement (usually queue driven) in each state frame to handle the commands. You thus have a loop with a double case structure. This can get somewhat unwieldy for large programs. Note that which case structure represents what will be determined by the relative number of each item. For example, if you have fifty commands and three states, the state should go into the command case.
So how do LabVIEW classes help? They can eliminate one or both levels of these case structures through the use of dynamic dispatch. This is done as follows. A parent class is created that is a generic command. It has commands for each state. For each actual command, a class is derived from the parent class. There are VIs in the specific command class for each state. A command is generated by creating the correct object for the current state, then calling the parent class command. Dynamic dispatch will execute the code for the correct command. The command execution loop is then reduced to a single command VI which dynamically dispatches based on the actual command and the current state.
In practice, things as usually not quite this simple, and you may want different cases for either different commands or different states so that you can change the connector pane of the dynamically dispatched VI as needed. Look up the LabVIEW examples on dynamic dispatch to see this in action.
I am afraid I have still not made myself clear. Keep asking questions and I will try to keep answering.
This account is no longer active. Contact ShadesOfGray for current posts and information.

Exit of queued state machine

Hello,
i have probleme existing an queued state machine vi :
I can't see how to do to make my vi stop before the wainting time here example is 3s (splitted in 25ms) .
I
thinkthere is a probleme flush queued or course competition something like that
but i a little new to this kind of codind that i'm a little bit lost.
here zip file of a minimized programme to isolate part that make me crazy
For the moment to make it run in a trash mode i put the 25ms wait out of case structure , it works but it means that every case take 25ms
and is not good job , because i have something like 20 cases in reality
Thank you for help
Best regards
Tinnitus
CLAD / Labview 2011, Win Xp
Mission d'une semaine- à plusieurs mois laissez moi un MP...
RP et Midi-pyrénées .Km+++ si possibilité de télétravail
Kudos always accepted / Les petits clicks jaunes sont toujours appréciés
Don't forget to valid a good answer / pensez à valider une réponse correcte
Attachments:
Ma distribution du code source.zip ‏97 KB

Well..
I was not able to get events you have registered with event structures. And also couldnot understand properly because of french texts.
Anyway, you are facing this problem due to the STTM Q MGR_new.vi in the consumer loop. You are queing more elements in each iteration. This causes your loop to hault untill this vi finishes execution although you have dequed exit case in the end.
So is it really necessary to have this vi outside the case structure? cant you use this vi to que elements in the producer loop? (loop above?)
. Or you can queue required elements inside the case structure of consumer loop.(Place this vi in whichever cases necessary)
As shown in the figure, move that vi either inside the case, or you can just que those when the user action takes place in the producer loop.
I hope i am clear in what i am trying to say. Your lower loop will never stop untill the STTM Q MGR_new.vi stops its execution, so it is necessary to meve as mentioned in the figures
Attachments:
Deque.PNG ‏64 KB

Need help with basic user events in Queued state machine example

I have written a little queued state machine example to try to teach myself about creating and using user events. The objective of the machine is to periodically choose a number (I'm doing it now with a control instead of a random number generator for troubleshooting), and compare that number with the number I have set in a control. When they match, I want to cause an event to fire so I can do something about having found a match. The examples in the LV Help file references show the events within the event structure, but I want to reach out of a state and cause an event ....
Can someone point me in the right direction here?
Thanks
Hummer1
Solved!
Go to Solution.
Attachments:
User Event Generator Example01 snip.png ‏102 KB

Yep....That was it...I had tried to do that but got fouled up with the variant definition...so defined the user event using a boolian and did the same in the case structure where I wanted to create the event and it worked great...
Thanks.
Here is the final version...not bulletproof, but does have a queued state machine using a user event to cause an event to fire.
Hope you find it useful.
Hummer1
Attachments:
User Event Generator Example01.vi ‏45 KB
Operating States Enum Example01.ctl ‏5 KB

Queued State Machine skipping states?

Hi,
I started out writing my application using a simple state machine but I realized it was necessary to make the application more interactive and prevent the UI from freezing when interupted. For example, I want the user to be able to abort the test by clicking the stop button or a reset button that sends the state machine sequential flow to the reset state.
I implemented the my QSM by looking at the example in the link below.
https://decibel.ni.com/content/docs/DOC-14169
However, the problem now is that the state machine no longer runs sequentially as in my initial simple state machine. Sometimes a state is repeated and at other times a state is skipped. By skipped, I meant it didn't follow the order I tried to implement in my code. I flush the queue before any new user input so I don't know what's causing this behavior in my application. Has anyone experienced this type of problem before? If so how can it be fixed.
Thanks

Hi
I'm still trying to find a solution to this problem. I was able apply a temporay remedy in an earlier application but in my current application, I'd have to find a permant fix to it. This problem is described in comment number 4 of the community example code link below. I tried to apply the recommended solution but it didn't work. Perhaps, I was doing it the wrong way. How will the example code be modified to fix the problem described in the comment? I will appreciate any suggestions. Thanks
https://decibel.ni.com/content/docs/DOC-14169
Comment4
This pattern has a potential risk of get cycled or get into unwanted states. Let me explain it. When you click on button, an event occurs and typically an element is enqueued to the queue. But in the lower loop another element is enqueued (in this case Report or Process). So when you for example want to go to idle state by clicking on the Stop button, you go to idle state but then you go to report or process state because the element was enqueued behind the idle element as explained above. The solution is to check if the queue is empty before enqueuing the element in the lower loop:
If the queue is empty, it is safe to enqueue element in lower loop:
If it is not empty (this occurs when an element is enqueued in the upper loop due to event occurence), the element will not be enqueued:

Tips to remember when using Queued State machine

I have been able to work through to convert my State Machine architecture to a QSM thereby eliminating using Local variables/property nodes to send values/data to my State machine but instead sending them through queues.
I would like some tips/advice on making use of them perfectly. Especially, "Not to do" stuff with queues and How to efficiently release a queue etc. What is the convention when using queues? Thanks!
V
I may not be perfect, but I'm all I got!
Solved!
Go to Solution.

VeeJay wrote:
Hmmm!! I jumped the gun... I would have to say, Neither... I guess it isn't really QSM or Queued message handler. My State machine is the generic one. But, data for the SM is obtained from a queue and feedback is sent back from the State machine through a queue. Does that clarify ?
BTW, good to know more variations.. Thanks!
That is a QSM.
I will defer to those that use them regularly.
I would only use such a a construct if the queue was limited to a single entry and prevented inserting multiple states at the front or back of the queue.
As long as the queue is limited to a single entry then a State Transition Diagram could be used to described all of the states.
The multiple entry version can be thought of as a method to implement a "goto" statement in LV. Very useful for those that come from a background working with stacks and pushing and popping off work and those that use them often love them.
But for me let me refer to a letter from Dijkstra quote from here
"GOTO Staements Concidered Harmful" goto statement introduces chaos
Ben
Ben Rayner
I am currently active on.. MainStream Preppers
Rayner's Ridge is under construction

Wiring constants into the queue in a queued, event driven state machine

I'm creating a queued state machine. Every time I change the queue control options to create a new event I have to recreate a constant in each queued event. Is there a way around this? I'm up to 27 events and changing them all is cumbersome. And I'm sure there are more to folow.

Are you using enums for your constants? If so, make a control from one, right click on it and under "advanced" select "customize" and when in the control editor change the pulldown from "Control" to "Type def." Save it with a useful name, and then in the vi in which you originally created it, use it to create a new constant. You will be able to select the different constant values were you need them and now when you want to add or subtract a "named" value you just click on the closest copy of the type def, either control or diagram constant, and choose customize (or double click into the tool editor if you made that choice in the options in the Tool pulldown at the top of the screen). Any changes you make will automatically be replicated everywhere you have used the typedef, whether a control, indicator or constant. Using enums also allows having case statements that have cases with the same names at the "named" value.
Hope this helps and is what you were refering too.
Putnam Monroe
Certified LabVIEW Developer
Putnam
Certified LabVIEW Developer
Senior Test Engineer
Currently using LV 6.1-LabVIEW 2012, RT8.5
LabVIEW Champion

Essbase process started in background is going on "In Queue" State

Hello,
I am using 11.1.2.1. Any Essbase process started in background is going on "In Queue" State. And the process never starts.
Any help would be appreciated.

Hi,
Try the following steps..
1. Stop EAS
2. Delete all the contents of WebLogic temp folder
Location: EPM_ORACLE_INSTANCE/../domains/EPMSystem/servers/EssbaseAdminServices0/tmp/ --> delete all the content under this folder
3. Start EAS server
Hope it helps...
KosuruS

An example of a state machine with transition array?

I am looking at state machine design patterns and am interested particularly in a state machine with boolean trasition array which defines the next state to be executed using an array. Here, the index of the first “True” boolean in the boolean array corresponds to the index of the new state in the array of enums. Has anyone got an example of this design pattern as it would greatly help in my understanding of it. Refer to figure 3c in http://zone.ni.com/devzone/cda/tut/p/id/3024#toc2 for clarity on what i am asking for.
Thanks in advance.

That seems like a lot of extra work. Why not just use a queue, and queue up the enum you want to go to next? Look up examples on queued state machine. No need for an array and then a boolean to index that array. here is an example
CLA, LabVIEW Versions 2010-2013

New LabHSM Toolkit - Agile development of complex event-driven maintainable LabVIEW applications with active objects / actors based on a universal Hierarchical State Machine / statechart template.

Dear Fellow LabVIEW programmers:
Most of the systems you deal with are reactive. It means that their
primary function is constant interaction with their environment by
sending and receiving events. But most likely, they can have something
happening inside them too, even when they are not processing messages
received from outside. So, such systems have to continuosly react to
external and internal stimuli. Right? Moreover, most likely, they
consist of subsystems that are reactive too and, in turn, can have
their own "life", to an extent independent from other parts (with
which they still communicate, of course). Reactive (event-driven)
systems are more naturally modeled with active objects. So, why then
should we try to model and code them with GOOP and its passive
("dead"!) objects?
"Flat" State Machines have been known for decades to have severe
limitations. It's been more than 20 years since Dr. Harel invented
Hierarchical State Machines (statecharts) to fight those limitations.
Then why does NI still tout the same old good Moore FSM as the
ultimate tool for event-driven programming in LabVIEW in its $995
State Diagram KIt?
The LabHSM toolkit we are happy to present, makes it possible to
easily create and then maintain complex event-driven applications in
LabVIEW as a collection of HSM-driven active object VIs using a higher
level of abstraction and agile software development methodologies.
These active object VIs are created based on a universal Hierarchical
State Machine ( HSM or statechart ) template. So. all your code looks
similar regardless of its functionality!
We all love just jump to code, right? However, to be good boys, we
need to do design first. Then implement it in code. If the logic is
modified we need to redo the design first and then redo the code. When
using LabHSM where behavior information is abstracted into a separate
HSM data file editable with a supplied editor, there is no need for
coding separate from design any more. The modified behavior becomes
code automatically as soon as the HSM file is saved. Design is code!
The implementation basically follows Dr. Samek's Quantum Programming
paradigm. (see http://www.quantum-leaps.com). However, as already
mentioned, LabHSM stores the behavior information in a file separate
from the code itself. It also adds state dependent priorities to
events, a separate queue for public events/messages, and, of course,
some LabVIEW specific code like capturing front panel user events and
putting them into the private Events queue. Communication and
instantiation functions are also rather specific for LabVIEW.
It is available for UNLIMITED PERIOD trial. Please visit
http://www.labhsm.com for details and download. The site also contains
references which you may want to check to learn more about
hierarchical state machines and active object computing.
Since this is our debut we will appreciate any comments and
suggestions. Our contact information is available on our site, of
course.
Have a G'day!

Symtx is currently hiring the following position. Please contact me if interested.
Amy Cable
Symtx, HR
[email protected]
Symtx, the leading supplier of functional test equipment, hires the brightest & most talented engineering professionals to design & manufacture complex custom electronic systems for advanced technology leaders in the defense, aerospace, communications, medical, transportation & semiconductor industries. Symtx’ challenging & dynamic work environment seeks to fill openings with highly qualified electronic engineering design professionals.The ideal candidate will be responsible for defining the requirements, software design and code development, and integration of test control software for custom functional test systems. Candidate should be familiar with data acquisition concepts, instrument control, complex test, measurement and calibration algorithm development and definition and implementation of control interfaces to hardware. Prefer familiarity with instrument control via GPIB, VXI, MXI, RS-232 desirable. Requires BS/MSEE and 3 -7+ yrs of experience in one or several of the following test applications in a Windows NT/2000/XP environment using Labwindows CVI, TestStand, Labview, Visual Basic, C++ and knowledge of RF systems is a plus. Job responsibilities will include software design, development, integration, team leadership, and interfacing with customers( includes PDR’s & CDR’s).

Unable to install the State Machine Toolkit in LabView 8.2

I am in the process of upgrading my version of LabView to 8.2.
I have the State Machine Toolkit working (well) on 8.0.1. I am attempting to install it in 8.2, but I have not had much success.
I can view a State Machine diagram in 8.2, but do not have the function in the palette to create one.
Any ideas ???
Thanks,
Chris.

It is a PAIN but it works.
http://digital.ni.com/public.nsf/allkb/58be852cb35237c786256a290079df39
Matthew Fitzsimons
Certified LabVIEW Architect
LabVIEW 6.1 ... 2013, LVOOP, GOOP, TestStand, DAQ, and Vison

Shutting down a queued event state machine with multiple parallel loops

I am trying to find the best way to shutdown a program that consists of a queued event state machine architecture with multiple parallel loops. Can anyone recommend the best way to accomplish this in my attached VI? (From browsing the forum, this seems to be a common question but I haven't found a solution that works for me.)
I welcome any other feedback on my code as well, if anyone is willing to offer it.
My Program Requirements:
If the user presses the "Shutdown" button, the program should prompt the user with "Are you sure you want to stop the program?" and then either return to the Idle state or proceed to stop the program. Additionally if there is an error, the program should prompt the user with "Clear error and continue, or Stop program?" Then either return to the Idle State or proceed to stop the program.
Details of architecture:
The program consists of 3 parallel loops: (1) an Event Handling loop that enqueues various States to a State Queue, (2) a State Machine which enters the latest state that is dequeued from the State Queue, and (3) an Error/Shutdown handling loop which processes any errors in the Error queue.
During normal Shutdown, in the Event Handling loop the "Program.Shutdown" event case executes, and the States "Shutdown" and "Idle" are added to the State Queue. In the State Machine, the "Shutdown" state is invoked. A special error code "5000" is added to the Error Queue. In the Error/Shutdown handling loop, the "5000" error triggers a prompt that asks the user if they want to stop the program. If the user chooses not to stop, a notifier StopNotif is sent to the "Shutdown" state and "Program.Shutdown" event case with the notification "Go". If the user chooses to stop, the notifier sends the notification "Stop". The Event handling loop and State Machine are terminated if they receive the notification "Stop".
In case of error, the program behaves similarly: if the user chooses to clear the error and continue, the program returns to the "Idle" state.
HOWEVER - if the user chooses to stop the program, the program stalls. The notifier that is sent to stop the Event Handling Loop and State Machine cannot be read because the Program.Shutdown event case and the Shutdown state (which contain the "Wait for Notifier" function) are not active.
I have been able to activate the Shutdown state by enqueuing it in the Error/Shutdown handling loop. But I don't know how to activate the "Program.Shutdown" event programmatically, and thereby access the "Wait for Notifier" function inside it.
I tried to place the "Wait for Notifier" function outside the event structure, but then the Event Handling loop never completes. Placing timeouts on the "Wait for Notifier" and on the Event structure makes the program work, but I want to avoid using timeouts because I don't want to turn my event-driven program into a polling-based program. I'd also like to avoid using variables or property nodes to stop the loops, because that requires creating a control/indicator for something that the user doesnt need to interact with.
Thank you!
Solved!
Go to Solution.
Attachments:
Queued event state machine parallel loops empty.vi ‏46 KB

Thanks for clarifying that, Ravens Fan.
I marked crossrulz as the solution for pointing out User Events to me.
I also adopted Ravens Fan's suggestion to keep the Shutdown procedure out of the Error Handling Loop. This has simplified the architecture by eliminating the need for Notifiers. Instead, I have used booleans in case structures to stop the Event Loop and State Machine, and Release Queue to stop the Error Handling Loop.
For reference, I'm attaching my corrected code.
Thank you to everyone who helped!
Attachments:
Queued event state machine parallel loops empty in progress.vi ‏44 KB

Advantages of Using Queued Message Handler vs. Standard State Machine

Hello,
What are the advantages of using a Queued Message Handler? Also, why are they more powerful than using Standard State Machines?
Thanks!

They are really just sort of an extension of a state machine. The general idea is that you have one loop doing a specific job. You then use a queue to tell it how/when to do this job. For instance, I might have a log file loop. I will send it commands to open a file, write some data, write some more data, and finally close the file. Each of those commands are coming from the queue. The beauty with this setup is that anybody that can get a reference to that queue can send the command to that loop.
So the QMH is "better" than a state machine mostly because of the decoupling of functions. In a given application, I will have a loop for log file writing, GUI updates, reading of a DAQ, instrumenet communications, server communications, etc. Trying to do all of that in a single loop state machine is a major pain in the rear end. Seperating them out makes life so much easier.
There are only two ways to tell somebody thanks: Kudos and Marked Solutions
Unofficial Forum Rules and Guidelines

LabVIEW Queued State Machine as Parellel Process Enabler

Similar Messages

Maybe you are looking for