State Machine - Revision history

Q at 20:02, 22 July 2021

2021-07-22T20:02:25Z

← Older revision		Revision as of 20:02, 22 July 2021
Line 41:		Line 41:

	The '''Natt Sequence''' template VI and its supporting VIM can be used in [[LabVIEW 2017\|LabVIEW 2017 SP1]] and later. See more on the [https://forums.ni.com/t5/Community-Documents/Natt-Sequence/ta-p/3970582?profile.language=en Natt Sequence]		The '''Natt Sequence''' template VI and its supporting VIM can be used in [[LabVIEW 2017\|LabVIEW 2017 SP1]] and later. See more on the [https://forums.ni.com/t5/Community-Documents/Natt-Sequence/ta-p/3970582?profile.language=en Natt Sequence]

			== Uses ==
			More to Come

	== See Also ==		== See Also ==

Q at 18:20, 19 July 2021

2021-07-19T18:20:41Z

← Older revision		Revision as of 18:20, 19 July 2021
Line 1:		Line 1:
	{{TOCright}}		{{TOCright}}
	The '''State Machine''' is one of the fundamental design patterns in LabVIEW. State machines are used to implement complex decision-making algorithms represented by state diagrams or flow charts. State machines are used in applications where distinguishable states exist. Each state can lead to one or multiple states, and can also end the process flow.		The '''State Machine''' is one of the fundamental [[Design Patterns\|design patterns]] in LabVIEW. State machines are used to implement complex decision-making algorithms represented by state diagrams or flow charts. State machines are used in applications where distinguishable states exist. Each state can lead to one or multiple states, and can also end the process flow.

	State machines consists of a [[Functions Palette/Programming/Structures/Case Structure\|case structure]] contained in a [[Functions Palette/Programming/Structures/While Loop\|while loop]]. The first state executed is determined by the input to the case selector. User input or in-state calculations determines which state to transition to next. The transition to the next state to execute is controlled through the use of a [[Shift Register\|shift register]]. By wiring the output from one case to the subsequent case (wiring to the shift register on the right hand side) and wiring the input to the case selector from the left hand side shift register, operations can be ordered according to which state is executed.		State machines consists of a [[Functions Palette/Programming/Structures/Case Structure\|case structure]] contained in a [[Functions Palette/Programming/Structures/While Loop\|while loop]]. The first state executed is determined by the input to the case selector. User input or in-state calculations determines which state to transition to next. The transition to the next state to execute is controlled through the use of a [[Shift Register\|shift register]]. By wiring the output from one case to the subsequent case (wiring to the shift register on the right hand side) and wiring the input to the case selector from the left hand side shift register, operations can be ordered according to which state is executed.

Q: /* Variations */ Added Natt Sequence

2021-07-19T18:08:25Z

Variations: Added Natt Sequence

← Older revision		Revision as of 18:08, 19 July 2021
Line 29:		Line 29:

	The VI Scripting Pattern is a variation of the State Machine design specifically for writing [[VI Scripting]] code. It uses an enum as the definition of the sequence of events in which to traverse incrementing through the enum for each state. Therefore the sequence of state execution is hard-coded. The VI Scripting Pattern will not repeat a state due to an enum not being able to have two entries of the same name unless two enum values are used for the same state. An error occurring in any state will cause the state machine to end. See more on the [https://www.mooregoodideas.com/technical-discussion/vi-scripting-pattern/ VI Scripting Pattern].		The VI Scripting Pattern is a variation of the State Machine design specifically for writing [[VI Scripting]] code. It uses an enum as the definition of the sequence of events in which to traverse incrementing through the enum for each state. Therefore the sequence of state execution is hard-coded. The VI Scripting Pattern will not repeat a state due to an enum not being able to have two entries of the same name unless two enum values are used for the same state. An error occurring in any state will cause the state machine to end. See more on the [https://www.mooregoodideas.com/technical-discussion/vi-scripting-pattern/ VI Scripting Pattern].

			=== Natt Sequence Pattern ===

			The '''Natt Sequence''' is a mini-pattern used for executing LabVIEW code sequentially. It has multiple benefits over other sequential code constructs (like the Flat Sequence, the Stacked Sequence, or the Sequence Loop), including:
			* Self-documenting via the sequence enum
			* No extra tooling required, just edit the sequence enum to add/remove/modify/rearrange sequence steps
			* Code breakage when the case structure doesn't have frames for all steps defined in the sequence enum
			* Minimal extra code
			* Shift registers to share data between sequence steps
			* Optional early break with For Loop conditional terminal

			The '''Natt Sequence''' template VI and its supporting VIM can be used in [[LabVIEW 2017\|LabVIEW 2017 SP1]] and later. See more on the [https://forums.ni.com/t5/Community-Documents/Natt-Sequence/ta-p/3970582?profile.language=en Natt Sequence]

	== See Also ==		== See Also ==

Q: Moved Table of Contents

2021-07-19T18:02:24Z

Moved Table of Contents

← Older revision		Revision as of 18:02, 19 July 2021
Line 1:		Line 1:
			{{TOCright}}
	The '''State Machine''' is one of the fundamental design patterns in LabVIEW. State machines are used to implement complex decision-making algorithms represented by state diagrams or flow charts. State machines are used in applications where distinguishable states exist. Each state can lead to one or multiple states, and can also end the process flow.		The '''State Machine''' is one of the fundamental design patterns in LabVIEW. State machines are used to implement complex decision-making algorithms represented by state diagrams or flow charts. State machines are used in applications where distinguishable states exist. Each state can lead to one or multiple states, and can also end the process flow.

Line 8:		Line 9:

	State machines can be based around integers, strings or enumerated types. The relative merits of each have been discussed in detail elsewhere. In summary an enumerated type state machine has the advantage of being automatically updated when the enum is changed (if the enum is a [[Type Definition]]) but has the disadvantage of requiring careful checking of all the code if new states (enums) are added or redundant states deleted. A string state machine has the advantage of easily added or removed states, but has the disadvantage of spelling mistakes causing programming errors (Note: this can be reduced by including the "Default" state showing the misspelled case in a pop up dialog box, as seen below).<br />[[Image:String_Based_State_Machine_Default_Case.png]]		State machines can be based around integers, strings or enumerated types. The relative merits of each have been discussed in detail elsewhere. In summary an enumerated type state machine has the advantage of being automatically updated when the enum is changed (if the enum is a [[Type Definition]]) but has the disadvantage of requiring careful checking of all the code if new states (enums) are added or redundant states deleted. A string state machine has the advantage of easily added or removed states, but has the disadvantage of spelling mistakes causing programming errors (Note: this can be reduced by including the "Default" state showing the misspelled case in a pop up dialog box, as seen below).<br />[[Image:String_Based_State_Machine_Default_Case.png]]

	~~__TOC__~~

	== Controlling Order of State Execution ==		== Controlling Order of State Execution ==

Q: Category reorg

2020-06-03T16:29:48Z

Category reorg

← Older revision		Revision as of 16:29, 3 June 2020
Line 43:		Line 43:
	*[https://en.wikipedia.org/wiki/State_machine_(LabVIEW_programming) Wikipedia Article].		*[https://en.wikipedia.org/wiki/State_machine_(LabVIEW_programming) Wikipedia Article].

	[[Category:Design ~~patterns~~]]		[[Category:Basic Design Patterns]]
	[[Category:LabVIEW fundamentals]]		[[Category:LabVIEW fundamentals]]

Q: Combined information from design pattern page

2020-06-03T16:24:12Z

Combined information from design pattern page

← Older revision		Revision as of 16:24, 3 June 2020
Line 1:		Line 1:
	The '''State Machine''' is ~~a convenient~~ LabVIEW ~~construct~~ where a case structure is contained ~~with~~ a while loop. ~~Execution of particular cases in the structure~~ is determined by the ~~output from~~ the ~~previous~~ case (or in ~~the instance of the first execution) by the control selector input~~. The ~~control of~~ the ~~order of case execution~~ is controlled through the use of a shift register. By wiring the output from one case ~~as the determinate~~ to the subsequent case (wiring to the shift register on the right hand side) and wiring the input to the case selector from the left hand side shift register, operations can be ordered according to which state is executed.<br />[[Image:Simple_State_Machine.png]]<br />		The '''State Machine''' is one of the fundamental design patterns in LabVIEW. State machines are used to implement complex decision-making algorithms represented by state diagrams or flow charts. State machines are used in applications where distinguishable states exist. Each state can lead to one or multiple states, and can also end the process flow.

			State machines consists of a [[Functions Palette/Programming/Structures/Case Structure\|case structure]] contained in a [[Functions Palette/Programming/Structures/While Loop\|while loop]]. The first state executed is determined by the input to the case selector. User input or in-state calculations determines which state to transition to next. The transition to the next state to execute is controlled through the use of a [[Shift Register\|shift register]]. By wiring the output from one case to the subsequent case (wiring to the shift register on the right hand side) and wiring the input to the case selector from the left hand side shift register, operations can be ordered according to which state is executed.

			<br />[[Image:Simple_State_Machine.png]]<br />

	The state machine has the advantage of allowing several steps to be linked in series so that each individual step can be executed (or debugged) easily. The trap for the inexperienced programmer is the use of the state machine to step in a haphazard fashion through the cases in the loop. This can lead to complicated pathways through the state machine reminiscent of convoluted goto statements in conventional text based languages. However state machines are a valuable tool and can be used very effectively with this in mind.		The state machine has the advantage of allowing several steps to be linked in series so that each individual step can be executed (or debugged) easily. The trap for the inexperienced programmer is the use of the state machine to step in a haphazard fashion through the cases in the loop. This can lead to complicated pathways through the state machine reminiscent of convoluted goto statements in conventional text based languages. However state machines are a valuable tool and can be used very effectively with this in mind.

Hooovahh: Updated external links and categories

2018-11-15T18:06:05Z

Updated external links and categories

← Older revision		Revision as of 18:06, 15 November 2018
Line 33:		Line 33:
	== External Links ==		== External Links ==

			*[http://www.ni.com/tutorial/7595/en/ NI Tutorial on State Machine Basics].
			*[https://www.youtube.com/watch?v=RuIN31rSO2k NI Video Event Driven Design].
			*[https://www.youtube.com/watch?v=aT0obtY3PRk Sixclear Video].
	*[http://jkisoft.com/state-machine JKI State Machine] - An easy-to-use yet powerful state machine template from [http://jkisoft.com JKI Software].		*[http://jkisoft.com/state-machine JKI State Machine] - An easy-to-use yet powerful state machine template from [http://jkisoft.com JKI Software].
			*[https://en.wikipedia.org/wiki/State_machine_(LabVIEW_programming) Wikipedia Article].

	[[Category:Design patterns]]		[[Category:Design patterns]]
			[[Category:LabVIEW fundamentals]]

Q at 03:25, 11 November 2018

2018-11-11T03:25:15Z

← Older revision		Revision as of 03:25, 11 November 2018
Line 1:		Line 1:
	The ~~state machine~~ is a convenient LabVIEW construct where a case structure is contained with a while loop. Execution of particular cases in the structure is determined by the output from the previous case (or in the instance of the first execution) by the control selector input. The control of the order of case execution is controlled through the use of a shift register. By wiring the output from one case as the determinate to the subsequent case (wiring to the shift register on the right hand side) and wiring the input to the case selector from the left hand side shift register, operations can be ordered according to which state is executed.<br />[[Image:Simple_State_Machine.png]]<br />		The '''State Machine''' is a convenient LabVIEW construct where a case structure is contained with a while loop. Execution of particular cases in the structure is determined by the output from the previous case (or in the instance of the first execution) by the control selector input. The control of the order of case execution is controlled through the use of a shift register. By wiring the output from one case as the determinate to the subsequent case (wiring to the shift register on the right hand side) and wiring the input to the case selector from the left hand side shift register, operations can be ordered according to which state is executed.<br />[[Image:Simple_State_Machine.png]]<br />

	The state machine has the advantage of allowing several steps to be linked in series so that each individual step can be executed (or debugged) easily. The trap for the inexperienced programmer is the use of the state machine to step in a haphazard fashion through the cases in the loop. This can lead to complicated pathways through the state machine reminiscent of convoluted goto statements in conventional text based languages. However state machines are a valuable tool and can be used very effectively with this in mind.		The state machine has the advantage of allowing several steps to be linked in series so that each individual step can be executed (or debugged) easily. The trap for the inexperienced programmer is the use of the state machine to step in a haphazard fashion through the cases in the loop. This can lead to complicated pathways through the state machine reminiscent of convoluted goto statements in conventional text based languages. However state machines are a valuable tool and can be used very effectively with this in mind.

Q: Added content from the FANDOM site.

2018-11-11T03:24:48Z

Added content from the FANDOM site.

← Older revision		Revision as of 03:24, 11 November 2018
Line 4:		Line 4:

	State machines can be based around integers, strings or enumerated types. The relative merits of each have been discussed in detail elsewhere. In summary an enumerated type state machine has the advantage of being automatically updated when the enum is changed (if the enum is a [[Type Definition]]) but has the disadvantage of requiring careful checking of all the code if new states (enums) are added or redundant states deleted. A string state machine has the advantage of easily added or removed states, but has the disadvantage of spelling mistakes causing programming errors (Note: this can be reduced by including the "Default" state showing the misspelled case in a pop up dialog box, as seen below).<br />[[Image:String_Based_State_Machine_Default_Case.png]]		State machines can be based around integers, strings or enumerated types. The relative merits of each have been discussed in detail elsewhere. In summary an enumerated type state machine has the advantage of being automatically updated when the enum is changed (if the enum is a [[Type Definition]]) but has the disadvantage of requiring careful checking of all the code if new states (enums) are added or redundant states deleted. A string state machine has the advantage of easily added or removed states, but has the disadvantage of spelling mistakes causing programming errors (Note: this can be reduced by including the "Default" state showing the misspelled case in a pop up dialog box, as seen below).<br />[[Image:String_Based_State_Machine_Default_Case.png]]

			__TOC__

	== Controlling Order of State Execution ==		== Controlling Order of State Execution ==
Line 14:		Line 16:
	== Passing Data Between States ==		== Passing Data Between States ==
	Data is commonly passed between the states of a state machine using a [[Shift Register]], similar to how the state variable is passed between states. It is a common practice to use a single [[Cluster]] (preferably a [[Type Definition]]) to hold all the data in a single [[Shift Register]], rather than multiple shift registers for multiple data elements.		Data is commonly passed between the states of a state machine using a [[Shift Register]], similar to how the state variable is passed between states. It is a common practice to use a single [[Cluster]] (preferably a [[Type Definition]]) to hold all the data in a single [[Shift Register]], rather than multiple shift registers for multiple data elements.

			== Variations ==

			=== Sequencer Pattern ===

			The Sequencer Pattern is a variation of the State Machine. Instead of a state leading to one or multiple states, the sequencer states are hard-coded in an array which dictates the order of execution. Only a state producing an error changes the sequence of operation by stopping the state machine. A state can be executed more than once by including it in multiple places in the hard-coded state array. See more on the [https://forums.ni.com/t5/Example-Program-Drafts/Sequencer-Template/ta-p/3842265 Sequencer Pattern].

			=== VI Scripting Pattern ===

			The VI Scripting Pattern is a variation of the State Machine design specifically for writing [[VI Scripting]] code. It uses an enum as the definition of the sequence of events in which to traverse incrementing through the enum for each state. Therefore the sequence of state execution is hard-coded. The VI Scripting Pattern will not repeat a state due to an enum not being able to have two entries of the same name unless two enum values are used for the same state. An error occurring in any state will cause the state machine to end. See more on the [https://www.mooregoodideas.com/technical-discussion/vi-scripting-pattern/ VI Scripting Pattern].

	== See Also ==		== See Also ==
Line 23:		Line 35:
	*[http://jkisoft.com/state-machine JKI State Machine] - An easy-to-use yet powerful state machine template from [http://jkisoft.com JKI Software].		*[http://jkisoft.com/state-machine JKI State Machine] - An easy-to-use yet powerful state machine template from [http://jkisoft.com JKI Software].

	[[Category:~~Design_patterns~~]]		[[Category:Design patterns]]

Jim Kring: Added external link to JKI State Machine

2009-02-07T00:17:23Z

Added external link to JKI State Machine

← Older revision		Revision as of 00:17, 7 February 2009
Line 15:		Line 15:
	Data is commonly passed between the states of a state machine using a [[Shift Register]], similar to how the state variable is passed between states. It is a common practice to use a single [[Cluster]] (preferably a [[Type Definition]]) to hold all the data in a single [[Shift Register]], rather than multiple shift registers for multiple data elements.		Data is commonly passed between the states of a state machine using a [[Shift Register]], similar to how the state variable is passed between states. It is a common practice to use a single [[Cluster]] (preferably a [[Type Definition]]) to hold all the data in a single [[Shift Register]], rather than multiple shift registers for multiple data elements.

	== See Also ==		== See Also ==
	* [[Queued State Machine]]

	[[~~category~~:~~design patterns~~]]		*[[Queued State Machine]]

			== External Links ==

			*[http://jkisoft.com/state-machine JKI State Machine] - An easy-to-use yet powerful state machine template from [http://jkisoft.com JKI Software].

			[[Category:Design_patterns]]