Finite State Machines and Micro Threds

7/27/2019 Finite State Machines and Micro Threds

1/75

1Copyright Micron Engineering 2007

Finite State Machines and

Micro Threads

Massimo Manca

Micron Engineering


2/75


What is this talk about?

Finite state machines

UML state chart as FSM notation

UML state chart to C code

UML state charts to C code using MicroFSM


3/75



A finite state machine (FSM)

or finite state automaton is

a model of behavior made

of a finite number ofstates,

transitions, and actions.


4/75


5/755Copyright Micron Engineering 2007







A state stores information

about the past, a transition

indicates a state change due

to a fulfilled condition...









A state stores information

about the past, a transition

indicates a state change due

to a fulfilled condition and

an action is a description of

an activity that is to be

performed at a given

moment.




Action types:

Entry action: performed entering a state

Exit action: performed exiting a state

Input action: performed depending on presentstate and input conditions

NOTE: Mealy and Moore FSM don't have exit actions.


8/75


FSM representation

FSM can be represented using a state diagram as above.Besides this, several state transition table types are

used. The most common representation is shown below:

the combination of current state and condition shows

the next state. The complete actions information can be

added only using footnotes. An FSM definition includingthe full actions information is possible using state tables.


9/75


FSM sequence detectorsAcceptors and recognizers (sequence detectors)

produce a binary output, saying either yes or no to

answer whether the input is accepted by the machine or

not. All states of the FSM are said to be either accepting

or not accepting. If when all input is processed the

current state is an accepting state, the input is

accepted; otherwise it is rejected. As a rule the input

are symbols (characters); actions are not used.

Above FSM recognize the word sos.


10/75


FSM mathematical model

An acceptor FSM is a quintuple (,S,s0, ,F), where:

is the input alphabet (a finite non empty set of symbols).

S is a finite non empty set of states.

s0

is an initial state, an element ofS. In a non deterministic

finite state machine, s0

is a set of initial states.

is the state transition function: = SS. F is the set of final states a (possibly empty) subset of S.


11/75


FSM transducer models

Transducers generate output based on a given input and/or astate using actions. They are used for control applications.

Here two types are distinguished also if in practice mixed

models are often used. Using exit actions (unknown in Moore

and Mealy models) inside FSM's states allows to achieve

optimal solutions minimizing the number of the states easy to

code as in the Moore model.

Moore machine

The next state of the FSM

depends only on the present

state, it uses only entryactions. The main advantage

of the Moore model is a

simplification of the

behaviour.

Mealy machine

The next state of the FSM

depends on inputs and present

state, it uses only inputactions. The use of a Mealy

FSM leads often to a reduction

of the number of states.


12/75


FSM mathematical model

A transducer FSM is a sextuple (,,S,s0,,) where:

is the input alphabet (a finite non empty set of symbols).

is the output alphabet (a finite non empty set of symbols).

S is a finite non empty set of states.

s0 is the initial state, an element of S. In a non deterministic

finite state machine, s0 is a set of initial states. is the state transition function: = SS. is the output function.

If the output function is a function of a state and input

alphabet S that definition corresponds to the Mealymodel. If the output function depends only on a state S that definition corresponds to the Moore model.


13/75


UML State Diagrams

The Unified Modeling Language (UML) state diagram isessentially a state diagram with standardized notation

that can describe a lot of things, from computer

programs to business processes. State charts were

developed by David Harel, to add nesting and other

features to flat state machines and were later added toUML and standardized. They are an excellent tool for

modeling modules (or classes), sub-systems and

interfaces that have many distinct states and complex

transitions among them. The following is a brief summary

of the notation and behavior of state charts. For a fullpresentation of the UML state chart notation, see the

UML 2.0 specification, available at:

www.omg.org/technology/documents/modeling_spec_catalog.htm


14/75


UML state notation

Graphically, UML shows

states as boxes with rounded

corners


15/75


UML transitions notation



corners and transitions as

arrows lines.


16/75






arrows lines. The transitions

are labeled with the event

that causes the transition.


17/75








that causes the transition. A

condition called guard can

be indicated in square

brackets...


18/75








that causes the transition. A

condition called guard can

be indicated in square

brackets followed by the

action(s) that will be taken

upon transition.


19/75


UML states detailedA state can be divided in 2

areas: the upper for its name


20/75




and the lower for its actions.

Actions are divided in:

entry actions:

executed entering the state


21/75






entry actions:


do actions:

executed inside the state


22/75






entry actions:


do actions:


exit actions:

executed leaving the state


23/75



areas: the upper for its nameand the lower for its actions.


entry actions:


do actions:


exit actions:

executed leaving the state

event actions:executed due to an event

(specified inside a transition)


24/75


25/75


UML pseudo statesThe UML notation for state

carts introduces new symbols:a pseudo state to mark the

initial state and a pseudo

state to mark the final state.


26/75


UML pseudo statesThe UML notation for state

carts introduces new symbols:a pseudo state to mark the

initial state and a pseudo

state to mark the final state.

Either connects to the states

by a transition that may becompleted with the notation

seen before with event, guard

and action fields.


27/75


28/75


29/75


UML junction point

NOTE: it is not mandatory that a junction point hastransitions to provide every possible conditions to

change state. In the above example there isn't a

transition for 3


30/75


UML choice point

A choice point always has1 entering transition and 2

or more exiting transitions

implementing a dynamic

choice based on the event

on the entering transition.The guard conditions are

evaluated reaching the

choice point so transitions

outgoing from choice point

have to provide guards to

cover all possible

conditions.

Suggestion: always

provide an else condition.


31/75


This FSM describes the procedure to start an engineusing a minimum notation:

The power of UML notation is due to its flexibility, it may

be used at different level of detail depending by user'sneeds; the user is responsible to balance the diagram

detail and the information contained in the diagram

itself.

State chart example 1


32/75


State chart example 2

This is a more detailed example used to understand theorder of the execution for all the actions inside a state

chart:

the execution order from left to right is:

lamp.on() printf(exiting ON) printf(to OFF)lamp.off() printf(exiting OFF)

printf(needless)


33/75


34/75


State chart symbols 2

The following are the remaining notational elements thatcan be used to make up a state diagram. Their use is

limited to concurrent states and their synchronization.


35/75


UML state charts to C code

There are 2 main well established methods to convert anUML state chart diagram to C:

A nested switch(..) statement with a scalar state

variable used as a discriminator in one level of the

switch and the event-type in the other.

A state table containing an (typically sparse) array oftransition for each state. The table lists event types

(triggers) along one dimension and the states along the

other.

Both methods have pros and cons, aren't well defined

and the implementation robustness depends by theprogrammer skills. I will propose MicroFSM a set of

constructs giving a simple method to translate a state

chart to an equivalent C code using simple templates.


36/75


MicroFSM implementation

I will propose a simple method to realize a state chart

using C code and simple templates.

MicroFSM proof of concept

Very portable, only pure ANSI C

Use the C preprocessor

None assembler required

Realized using the switch() statement under the hood

None library required, only a file to include

Short learning curve

Printed templates to manually code a state chart


37/75



In MicroFSM a state chart have to be entirely contained

inside a C function...

FsmDeclare(LightFsm(char off));


38/75



In MicroFSM a state chart have to be entirely contained

inside a C function...


that may have any number of parameters of any type...

FsmDeclare(EngineFsm(int reset, char*err));


39/75



In MicroFSM a state chart have to be entirely containedinside a C function...




and returns an int representing its running state...

int s = EngineFsm(0, strErr);


40/75



In MicroFSM a state chart have to be entirely containedinside a C function...




and returns an int representing its running state...

int s = EngineFsm(0, strErr);

MicroFSM running state can be one of these:

ENDEDthe fsm ended its execution cycle, at next invocationit will restart from its starting state

EXITEDthe fsm terminated its executions for ever

WAITINGthe execution point is inside a state


41/75



FsmDeclare(LightFsm(char off))

{

FSM_STATES ON=FIRST_STATE, OFF // states declared

...

}

In MicroFSM a state chart is made of a set of states...

Mi FSM i l i


42/75




{

FSM_STATES ON=FIRST_STATE, OFF // states declar.

FSM_BEGIN // fsm entry point

...FSM_END // fsm end

}


the fsm has its entry point and its block of code...

Mi FSM i l i


43/75




{



...FSM_STATE(ON) // this is

state ON...

FSM_STATE_END // end state ONFSM_STATE(OFF) // this is state OFF

...FSM_STATE_END // end state ON

FSM_END // fsm end}



every state has its block of code...

Mi FSM i l t ti


44/75




{



...FSM_STATE(ON) // this is

state ONif(off)

FsmNextState(OFF);FSM_STATE_END // end state ONFSM_STATE(OFF) // this is state OFF

...FSM_STATE_END // end state ON

FSM_END // fsm end

}

In MicroFSM basically a state chart is a set of states...


every state has its block of code...

transitions are embedded in the source state...


45/75

Mi FSM i l t ti


46/75



...

FSM_STATE(ON) // this is

state ONif(off)print(exitingON);...

In MicroFSM a transitions consist in a guard condition to test

followed by an action (a block of code) to do

Mi FSM i l t ti


47/75



...

FSM_STATE(ON) // this is

state ONif(off) {print(exitingON);FsmNextState(OFF);

}...

In MicroFSM a transitions consist in a guard condition to test

followed by an action (a block of code) to do and thejump to

the new state

THIS IS ATRANSITION



48/75



// these 2 blocks are equivalent

...FSM_STATE(ON)FsmChangeState(off, OFF);...

FSM_STATE(ON)if(off);

FsmNextState(OFF);......

FSM_STATE(OFF)FsmTransition(off, printf(needless), OFF);

...

To manage the transitions there are more constructs,

FsmTransition(guard, exec, nextstate) is the more complete

but to conditionally change state without execute any action

FsmChangeState(guard, nextstate) is the best one.

THESE AREALL THE SAME

TRANSITION

COMPLETE TRANSITION

MicroFSM under the hood


49/75



#define FIRST_STATE -127

#define FSM_EXITED 0

#define FSM_WAITING 1#define FSM_ENDED 2

#define FSM_DECLARE(name_args) int name_args

#define FSM_STATES static enum eFsmState {

#define END_STATES } eStateCnt=FIRST_STATE; char cSuspend=1;

#define FSM_BEGIN END_STATES FSM_START

#define FSM_STATE(a) case a :

#define FSM_STATE_END break;#define FsmChangeState(cond, nextstate) \

if(cond) eStateCnt=nextstate

#define FsmNextState(nextstate) eStateCnt=nextstate

#define FsmSuccState() eStateCnt=eStateCnt + 1

#define FsmPrevState() eStateCnt=eStateCnt - 1

The complete implementation of MicroFsm is contained in

about 60 lines of C preprocessor directives based on switch()

instruction and local continuations, these are those discussed

in the previous pages:



50/75


MicroFSM under the hoodWhat are the difference between a FSM implemented with

normal switch() construct and MicroFSM?

MicroFSM syntax give prominence to states and transitions

MicroFSM details are hidden on the function containing it

MicroFsm flexible syntax permits to realize a function with

FSM and mixed normal procedural code

MicroFSM has pre defined constructs able to solve commonsituations as suspend and restart its execution

MicroFSM has constructs able to handlepseudo statesMicroFSM execution can continue across 2 or more states until

there is something to wait for

MicroFSM syntax masks a more efficient C code

MicroFSM can be expanded and adapted to a lof of situations



51/75


MicroFSM under the hoodWhat arepseudo states in UML?

The UML state chart notation defines pseudo state the

initial and last state symbols because they aren't realstates but just a graphic sign evidencing 2 states.

What arepseudo states in MicroFSM?

A pseudo state is every state that can be realized with a

blocking wait construct without altering the original

behaviour.

What is a blocking wait in MicroFSM?

It is a construct that evaluates a guard condition, if true it

will continue the execution flow of the FSM code, if false itwill exit from the FSM and next time the execution flow of

the FSM will start from the blocking wait construct.



52/75


What blocking wait constructs are provided in MicroFSM?

They are:

FsmWaitUntil(condition)

FsmWaitWhile(condition)

FsmDoWaitUntil(exec, condition)

FsmDoWaitWhile(exec, condition)

FsmSuspend()

FsmSuspendUntil(condition)

and how are implemented blocking wait constructs?

They are:

based on local continuationsinspired to proto threads created by Adam Dunkels

done with switch()...case and enum ANSI C instructions

contained on a C function (also the state variable)




53/75



#define FsmWaitUntil(condition)\do { \

FSM_SET(eStateCnt); \if(!(condition)) \

return(FSM_WAITING); \

} while(0)

#define FsmSuspend() \

do { \

cSuspend = 0; \

FsmWaitUntil(cSuspend); \

} while(0)

#define FsmSuspendUntil(cond) \

do { \

cSuspend = 0; \

FsmWaitUntil(cSuspend || !(cond)); \

cSuspend = 1; \

} while(0)

This is the implementation of blocking wait constructs

implemented in MicroFsm: page 1



54/75



#define FsmWaitWhile(condition) \

FsmWaitUntil(!(condition))

#define FsmDoWaitUntil(exec, condition) \

do { \

FSM_SET(eStateCnt); \exec; \

if(!(condition)) \

return(FSM_WAITING); \

} while(0)

#define FsmDoWaitWhile(exec, condition) \

FsmDoWaitUntil(!(condition))

This is the implementation of blocking wait constructs

implemented in MicroFsm: page 2



55/75


MicroFSM under the hoodAll the magic is contained in a single row:

#define FSM_SET(s) s = (int)__LINE__; case __LINE__:



56/75




this is the implementation of a local continuation; the

__LINE__ macro during compilation is replaced with the

current line number as an integer constant. This

implementation works inside a MicroFSM because __LINE__

constant can't be equal with any state label that are definedinside FSM_STATES.



57/75








constant can't be equal with any state label that are definedinside FSM_STATES. The following example...

FSM_STATES ON=FIRST_STATE, OFF // states declaration

FSM_BEGIN

...

after preprocessing will be expanded as:



58/75








constant can't be equal with any state label that are definedinside FSM_STATES. The following example...

FSM_STATES ON=FIRST_STATE, OFF // states declaration

FSM_BEGIN

...

after preprocessing will be expanded as:static enum eFsmState{ ON=-127, OFF }eStateCnt=-127;char cSuspend=1;

switch(eStateCnt) {

...



59/75


MicroFSM under the hoodSo notations for transitions and blocking wait constructs

can be intermixed; what is the advantage?Using MicroFSM a lot of states collapses in pseudo states

because in FSMs a lot of states require only one transition

Code is more compact

To convert a FSM to C code we can identify the simpler

FSM buildingblocks and convert them to C code, then use

them as a set of templates.

MicroFSM templates


60/75


MicroFSM templates

This is a sequence:...

FsmTransition(guard,event(),B);

... // or

if(guard) {

event();

FsmNextState(B);

}

... // or

if(guard) {

event();

FsmSuccState();}

... // or

FsmWaitUntil(guard);

event();

MicroFSM templates


61/75


MicroFSM templates

This is an iteration: while(g1) {

if(g2) {

e2();

FsmNextState(B); }

e1();

}

... // or

while(g1) {

FsmWaitUntil(!g1 || g2);

FsmTransition(g2,e2(),B);

}

e1();}

B is supposed to be the next state. Pay attention to chooseg1 to be sure that the only way to exit from the while loop

is when g2 is evaluated true.

MicroFSM templates


62/75


MicroFSM templates

This is a selection: FsmTransition(g1,e1(),B);FsmTransition(g2,e2(),C);... // orFsmWaitUntil(g1 || g2);if(g1) {

FsmNextState(B);e1();

}else if(g2) {

FsmNextState(C);e2();

}... // or

FsmWaitUntil(g1 || g2);FsmChangeState(g1,B);FsmChangeState(g2,C);...

MicroFSM templates


63/75


M c o SM te plates

This is always a selection: FsmTransition(g1,e1(),B);FsmTransition(g2,e2(),C);... // orFsmWaitUntil(g1 || g2);if(g1) {

FsmNextState(B);e1();

}else if(g2) {

FsmNextState(C);e2();

}... // or

FsmWaitUntil(g1 || g2);FsmChangeState(g1,B);FsmChangeState(g2,C);...

MicroFSM templates


64/75


p

Let's try to add a do action:FSM_STATE(A)

c++;

FsmTransition(guard, \

event, B);

FSM_STATE_END

... // or

FsmDoWaitUntil(c++,guard);

event();

...

if the action is more complex it may be a block of

instructions or a function call for example:

FsmDoWaitUntil(b=GainGet(), b>10);

MicroFSM templates


65/75


p

Let's try to add an exit action:FSM_STATE(A)

...

if(g1 || g2)

ex();

FsmTransition(g1,e1(), B);

FsmTransition(g2,e2(), C);

FSM_STATE_END

... // or

FsmWaitUntil(g1 || g2);

ex();

FsmTransition(g1,e1(), B);

FsmTransition(g2,e2(), C);

...

MicroFSM templates


66/75


p

Let's try to add an entry action:FSM_STATE(Aentry)

entry();

FsmSuccState();

FSM_STATE(A)

FsmTransition(g1,e1,B);

FSM_STATE_END

... // or

entry();

FsmWaitUntil(g1);

e1();...

MicroFSM examples


67/75


p

Ok, it is time to try a complete simple exercise, we can

get the lamp state chart and transform to a complete

piece of C code:

MicroFSM examples


68/75


1: FsmDeclare(LightFsm(char off, int gpo)) {2: FSM_STATES ONentry=FIRST_STATE,ON,OFFentry,OFF // statesdecl.3: FSM_BEGIN4: FSM_STATE(ONentry) // this is entry ON5: lamp.on(); // entry action6: FsmSuccState();7: FSM_STATE(ON)8: if(off) { // transition guard test

9: printf(exiting ON); // exit action10: FsmSuccState(); // change state

11: printf(to OFF); // transition action12: }13: FSM_STATE_END // end state14: FSM_STATE(OFFentry)15: lamp.off(); // entry action16: FsmSuccState();17: FSM_STATE(OFF)18: while(off && !gpo) { // stay hereconditions19: if(off || gpo) // transitions guards cond.

20: printf(exiting OFF); // exit action21: if(gpo) FsmExit(); // test final state guard

22: else if(off) printf(needless); // auto transition..23: } //... guardtest24: FSM_STATE_END25: FSM_END

26:}

p

MicroFSM examples


69/75


The code is compact and shows from the first line that it

implements a FSM; its dedicated syntax give prominence to

states and transitions making possible associations label-state

and function-transition. So I give a complete description of

the code and the implementation.

FsmDeclare(LightFsm(char off)) is the C function

prototype specialized for FSMs, it is important to say that thefunction may have an arbitrary number of parameterswithout requiring any change to te macro. So I may write:

FSM_DECLARE(ModemFsm(char input))

or:

FSM_DECLARE(ModemFsm(char input, int timer))

as required from the specific application.


70/75

MicroFSM examples


71/75


This is an alternative solution using pseudo states constructs:

1: FsmDeclare(LightFsm(char off, int gpo)) {2: FSM_STATES ONentry=FIRST_STATE,ON,OFFentry,OFF // statesdecl.

3: FSM_BEGIN4: FSM_STATE(ON) // this is state ON5: lamp.on(); // entry action

6: FsmWaitUntil(off); // transition guard test7: printf(exiting ON); // exit action

8: printf(to OFF); // transition action9: // state OFF10: lamp.off(); // entry action11: while(off && !gpo) { // stay hereconditions

12: FsmWaitUntil(off || gpo); // transitions guards cond.13: printf(exiting OFF); // exit action14: if(gpo) // test final state guard15: FsmExit();

15: else {16: if(off) //... guard test17: printf(needless); // auto transition..

18: }19: }20: FSM_STATE_END21: FSM_END22:}

MicroFSM examples


72/75


FsmWaitUntil(off)

If off is true the execution will continue on the next

instruction otherwise it will exit the FSM and next FSM entry

point will be the FsmWaitUntil(...) row.

FsmExit()

It will exit from the FSM; next state will be FIRST_STATE.

The main difference with the previous version is that the

code is shorter and there isn't FSM_STATE_END for state ON

so the execution can pass trough from state A to state B

without returning to the calling function.


73/75


74/75

MicroFSM templates


75/75


1: #define BYTE_OF(a, b) (a)2: #define BIT_OF(a,b) (1

Date post:	02-Apr-2018
Category:	Documents
Upload:	neethusubrahmanyan
View:	218 times
Download:	0 times

Finite State Machines and Micro Threds

Documents