If you missed my talk, or if you just can’t get enough, don’t worry; the slides and sample code are now available for download below. If you’re interested in interprocess communication in LabVIEW, or if you just want to see a novel use for LabVIEW’s User Events, please give this framework a try! And as always, comments/questions/criticism are encouraged. Join the discussion below.

If this is your first exposure to the JKI State Machine, welcome! The JKI State Machine is a simple yet flexible and powerful template that forms the backbone of everything we do at JKI. You can use it for free in all your projects. Visit our JKI State Machine pages to get started.

Title: Beyond State Machines: Building Modular Applications in LabVIEW

Abstract: Nearly every significant LabVIEW application uses multiple loops and several pieces of hardware. Coordinating these moving pieces can create a recipe for unreadable code. Learn how to use a template for interprocess communication based on “public” and “private” events that is easy enough for intermediate developers but powerful enough for Certified LabVIEW Architects.

Download Slides & Code: niweek-2011-jki-beyond-state-machines.zip (4.5 MB)

Notes:
Example code requires LabVIEW 2009 or later.
Example code requires the JKI State Machine. Install the JKI State Machine using the free VIPM 2011 Community Edition if you don’t already have it.

In the meantime, I have a different suggestion:  memorize enough of your favorite state machine template to recreate it from scratch in 10 minutes or less. You can do this with any template, but I’m going to show you how I did it with the JKI State Machine (JKISM) when I took my Certified LabVIEW Architect exam (CLA).

How to Create a Basic JKI State Machine From Scratch in 10 Minutes

You don’t need the world’s greatest template to rock your CLD or CLA exam.  There are only a few features you really need to “feel” like you’re working with the JKISM:

• Your own version of the “Add State(s) to Queue” VI to manage your state queue.
• A basic version of the “Parse State Queue” VI to drive your case structure.
• A few simple, standard states:
  • Idle, with an Event Structure for catching UI events
  • Default, with an exception handler to raise an error when you misspell a state name
  • Error Handler, to catch and process any errors that occur
  • Exit, to exit your state machine
  • Data: Initialize, to set up your state machine’s local data

That’s only a handful of things, and they’re all simple!  I’ll describe them, and then if you practice them for about an hour the day before your test, you’ll have no trouble replicating them on the fly come test time.

Your Very Own “Add State(s) to Queue”

The JKISM’s “Add State(s) to Queue” VI is pretty easy.  It just ensures that every incoming state (or state queue) ends with a linefeed (LF), and throws some Trim Whitespace operations in there so the resulting state queue doesn’t have extra LFs hanging around.  It’s not hard to literally memorize this VI and recreate it from scratch.

Your Very Own “Parse State Queue”

“Parse State Queue” is a little more complicated, but the trick is that you only need a simplified version of it.  In particular, you need it to extract the first line from a multi-line string state queue, and branch to the Error Handler. That’s really it.  You don’t need to handle disabled states (or state comments), nor do you need to handle state arguments.  This eliminates the vast majority of the VI’s code…

…and leaves you again with something you can definitely memorize:

Now Go Make a State Machine Template!

The two VIs you just created are the building blocks of your state machine: they enqueue and dequeue states.  Now you just have to glue them together to form the skeleton of a working application.

A few basic states of the JKISM will give you everything you need.  Rather than listening to me describe each of them, though, just download the JKI State Machine (VIPM users can install it directly) and see them for yourself.  They’re all pretty trivial.  The hardest part is remembering which states are important.  I use a mnemonic to help myself:

• I - Idle
• Doubt – Default
• Elvis – Error Handler (or, if you prefer, ELVIS)
• Ever – Exit
• Died – Data: Initialize

These five states give you a functional, extensible state machine with support for events, local state data, and error handling.  Speaking from experience, that’s all you need.

OK, It’s Not Really ALL You Need

Memorizing your favorite state machine template will definitely make your CLD or CLA exam experience easier because you won’t have to worry about using unfamiliar design patterns or sweating to figure something out on the fly.  But don’t neglect the other aspects of exam preparation! In particular, don’t miss Darren Nattinger’s great advice on Preparing for the CLD and recent Changes to the CLA.  Good luck!

Do you have tips for helping developers pass their CLD or CLA exam?  Any horror stories from your own exam?  Join the discussion below!

We want to thank you — our users, consulting customers, and the LabVIEW community — for helping make our jobs fun and rewarding. So between now and the end of the year, we’re giving you 20% off any JKI product.

We’re also giving you the chance to help people who really need it. Each time you save 20%, we’ll also donate 10% of the pre-discount price to the Red Cross to provide clean water, medical care, and humanitarian aid to Haiti in the wake of this year’s devastating earthquake and recent cholera outbreak.

Photo courtesy of Flickr user 'mmlolek'

Enter the code JKI-HOLIDAY-2010 at checkout, and we’ll take care of the rest.

Need to purchase or renew a VIPM license? Been dying to get your hands on the EasyXML Toolkit for LabVIEW? Finally ready to simplify your TortoiseSVN workflow? Do it by December 31, 2010 to help the people of Haiti and save a bit for yourself too.

Enjoy your holiday season!

If you follow me on Twitter or are my Facebook friend, you would’ve known right away about the LabVIEW-, LEGO Mindstorms-, and Twitter-powered popcorn-popping contraption a friend and I built recently.  We built it to enter a contest, where the object was to make a video showing the “most inventive way to pop this all-American snack.”

Our first idea was a winner:  Crowd-sourced Popcorn.

www.youtube.com/watch?v=0HsE6tkWCzM

Since we uploaded it last week, the video has gone viral.  It was picked up first by Engadget, but things got really big when it hit Mashable.  Even now, there’s a steady stream of #popcorn tweets on Twitter, as people send the link around and around to their friends.  Most importantly, we won the contest.

What does this have to do with JKI?

If you watch the video, you can clearly see that the famous JKI State Machine plays a starring role.  I got to thinking, though, that the JKI State Machine is by no means the only important piece of the puzzle.  I used a whole bunch of JKI products!

• I used the JKI State Machine as a template for the whole application.
• I used JKI’s VI Package Manager to install the required OpenG libraries and EasyXML.
• I used JKI’s EasyXML to parse the results returned from the Twitter Search API.
• I used the JKI TortoiseSVN Tool for LabVIEW to easily sync the code to my Subversion server.

We didn’t spend a lot of time designing and building the Popcorn Tweets system.  After all, I have a real job at JKI.  But luckily, I live in a world where NI makes great products like LabVIEW, and where NI partners like JKI can extend the platform and provide great tools to help people turn any idea into reality!

Want More Technical Info?

I’ve posted a technical overview of the system on NI’s LabVIEW DIY Crew group.  Check it out!

The engineers at Endevo have put together a great video that shows how to use their UML Modeller with the JKI State Machine:

Click here to watch it.

And don’t forget, the JKI State Machine is a free tool from JKI Software.  You can always learn more about it at jkisoft.com, or install it in just a few clicks using VI Package Manager™.

Stefan wrote:

“I just wanted to say that your state machine is incredible.  I am a beginner-to-midlevel Labview user, and I had wanted to implement state machines for a long time, but had no idea how to go about it without using C. I found your state machine last week, and using it I reduced the development time of an automated test rig from about a month down to one day. I was going to suggest putting up some more examples and tutorials, but I found the one tutorial was all I needed to figure out what was going on. Keep up the good work.”

It’s awesome to hear that the JKI State Machine reduced a month’s worth of work down to one day.  And, I’ll bet that Stefan’s code will be easier to maintain in the long run, too, which will save even more time.

Stories like this are why we love to work hard creating great tools for LabVIEW.  So, if you’ve tried the JKI State Machine and it’s made a difference in your LabVIEW work, please send us your feedback.