State Machines

State Machines • You use the state machine design pattern to implement algorithms that can be described by a state diagram or flow chart. • A state machine, which is more precisely defined as a finite state machine, consists of a set of states and a transition function that maps to the next state. • The two most common finite state machines are the Mealy machine and the Moore machine.

State Machines • A Mealy machine performs an action for each transition. • A Moore machine performs a specific action for each state in the state transition diagram. • The state machine design pattern template in LabVIEW implements any algorithm described by a Moore machine. • Each state can lead to one or multiple states or end the process flow.

State Machines • A state machine relies on user input or in-state calculation to determine which state to go to next. • Many applications require an initialization state and a default state, where many different actions can be performed.

State Machines Translating the state transition diagram into a LabVIEW block diagram requires the following components: • • • • •

While Loop Case Structure Shift Register State Functionality Code Transition Code

State Machines • The flow of the state transition diagram is implemented by the While Loop. • It continually executes the various states. • The individual states are represented by cases in the Case structure • It contains a case for each state and the code to execute for each case.

State Machines • A Shift register on the While Loop keeps track of the current state and communicates the current state to the Case structure input. • The State functionality code is used to implement the function of the state. • The transition code determine the next state in the sequence.

Enum Data Type • An enum data type is a combination of data types. It represents a pair of values, such as a string and a numeric. • The enum can be one of a list of values. • For example, if you created an enum type called Month, the possible value pairs for a Month variable are January-0, through December-11. • Enums are useful because manipulating numbers on the block diagram is easier than strings.

Enum Data Type

Controlling the State Machine • Use enumerated type controls as case selectors to control the initialization and transition of state machines. •

With enumerated type controls, if a user attempts to add or delete a state from the enumerated type control, the remaining wires connected to the copies of this enumerated type control break.

•

One solution to this problem is to type define the enumerated control.

• Creating a type defined enumerated type control causes all the enumerated type control copies to automatically update if you add or remove a state.

Controlling the State Machine

Transition Code • Use enumerated type controls to control the initialization and transition of state machines. • There are several common design patterns used to develop the transition code. • You choose the transition code design pattern based on the number of states you need to transition between: • Transitioning to another state (Default Transition) • Transition between two possible states • Transition among two or more possible states

Transition Code

Default Transition A design pattern that uses a default transition implemented for a temperature data acquisition system is displayed. For the default transition, no code is needed to determine the next state, as there is only one possible choice.

Transition Between Two States • There are several patterns commonly used to accomplish transition between two states. • The Select function transition implemented for a temperature data acquisition system is displayed. • This method works well if you know that the individual state always transitions between two states. • However, this method limits the scalability of the application. If you need to modify the state to transition among more than two states, this solution would not work and would require a major modification of the transition code

Transition Between Two States

Transition Among Two or More States • You can create a more scalable architecture by using one of the following methods for transition among multiple states. • Case Structure • Transition Array • State Diagram Tool Kit

Using the Case Structure • Each case in a Case structure corresponds to an item in the enumerated type control, making it easy to read and understand the code. • A Case structure is also scalable and you can add more transitions to a particular state by adding more cases to the Case structure. • However, due to the nature of the Case structure, you cannot see the complete functionality of the transition code at a glance.

Using Transition Array • If you need more of the code to be visible, you can create a transition array for all the transitions that can take place in the transition code for a state. • You can also index the Boolean array for the next state.

Using Transition Array

Using State Diagram Toolkit • The State Diagram Toolkit uses a large Case structure for every state and a smaller While Loop that iterates through the state transitions until the proper state transition is met. • It also adds the State Diagram Editor function to LabVIEW to visually draw the logic that defines an application, and generate the LabVIEW code that acts as the foundation of your application.

Using State Diagram Toolkit

State Machine Design Pattern • It usually has a start up and a shut down phase. • The main application phase consists of a Case structure embedded in the loop. • This architecture allows you to run different code each time the loop executes depending upon some condition. • Each case defines a state of the machine, hence the name, state machine. • Use this design pattern for VIs that are easily divided into several simpler tasks, such as VIs that act as a user interface.

State Machine Design Pattern • Each state of the state machine is a separate case in the Case structure. • Place VIs and other code that the state should execute within the appropriate case. • A shift register stores the state that should execute upon the next iteration of the loop. • The block diagram of a state machine VI is displayed. The possible states are Startup, Idle, Event 1, Event 2, and Shutdown.

State Machine Design Pattern •

For the displayed VI, the possible states are Startup, Idle, Event 1, Event 2, and Shutdown. An enumerated constant stores the states. Each state has its own case in the Case structure. The outcome of one case determines the case that next executes. The shift register stores a value that determines which case runs next.

State Machine Design Pattern • • •

The state machine design pattern can make the block diagram much smaller, and therefore easier to read and debug. Another advantage of the state machine architecture is that each case determines the next state, unlike Sequence structures that cannot skip a frame. A disadvantage of the state machine design pattern is that it makes it possible to skip states. If two states in the structure are called at the same time, this model handles only one state, and the other state does not execute.