How to deeply understand the design idea of "finite state machine"?

How to understand “ Finite state machine ” Design idea ？

It is often used in program design and digital circuit design “ Finite state machine ” Design idea .

In embedded software development , State machine programming is a very important programming idea , It is also a common programming framework in embedded development . Master the programming idea of state machine , It can realize complex business logic functions more logically .

1 State machine thinking

State machine , Or finite state machine FSM（Finite State Machine）, Is an important programming idea .

The state machine has 3 elements ： state 、 Events and responses

· state ： What state is the system in ？

· event ： What is going on? ？

· Respond to ： In this state, something like this happens , How does the system handle ？

Before state machine programming , First, according to the functions to be realized , Sort out a corresponding state transition diagram ( The state machine diagram ), Then you can use this state transition diagram , Apply the state machine programming template , The implementation corresponds to the state machine code .

State machine programming mainly includes  3 Methods ：switch-case Law 、 Table driven method 、 Function pointer method , This article first introduces the simplest and easiest to understand switch-case Law .

2 State machine instance

The following is the key shake elimination function , To introduce switch-case Method of state machine programming ideas .

2.1 Button anti shake state transition diagram

Before state machine programming , First of all, the state machine corresponding to the function needs several states , The key function of this example , Only the most basic pressed and released states are detected （ Long press will not be realized for the time being 、 Double click status ）, And add the corresponding button de dithering function , therefore , Need to use 4 Status ：

· Stable release state

· Press jitter status

· Steady press state

· Release the jitter state

The corresponding state transition diagram is as follows ：

Because the key is usually released , Here, let the initialization state of the state machine be the released state , And here 4 Switch back and forth between states .

In the picture VT Represents the level detected by the key ,VT=0 That is, low level is detected , It may be a key press , From the initial “ Stable release ” The state changes to “ Press jitter ” state

When a low level is continuously detected (VT=0) After a while , It is considered that the chattering elimination is completed , from “ Press jitter ” The state changes to “ Press steadily ” state

stay “ Press jitter ” In the state of , Within a specified period of time , High level detected again (VT=1), It shows that the button jitters （ For example, the key is quickly pushed and then bounced up , Or key jitter caused by strong vibration ）, By “ Press jitter ” The state changes to “ Stable release ” state

2.2 Programming to realize

2.2.1 State definition

Corresponding to the above button state diagram , You know you need to use 4 Status ：

· Stable release state （KS_RELEASE）

· Press jitter status （KS_PRESS_SHAKE）

· Steady press state （KS_PRESS）

· Release the jitter state （KS_RELEASE_SHAKE）

Enumerations are used here to define this 4 Status . For debugging , The corresponding state name can be printed in the form of string , Here is a trick to use macro definition ：

# Symbol + Custom enumeration name

It can be automatically converted to string form , Then put these strings into const char* key_status_name[] Array , You can access the string name form of these states in the form of an array .

Besides , In order not to repeatedly write the enumeration name and the corresponding enumeration string (#+ Enumeration name ), Further use of macro definitions , Define the state only once , Then define the following two macros , Realize the separate acquisition of enumeration items and the strings corresponding to enumeration items ：

#define ENUM_ITEM(ITEM) ITEM,#define ENUM_STRING(ITEM) #ITEM,

Specifically, the macro definition 、 The enumeration definition and enumeration name array are declared as follows ：

#define ENUM_ITEM(ITEM) ITEM,#define ENUM_STRING(ITEM) #ITEM,#define KEY_STATUS_ENUM(STATUS) \ STATUS(KS_RELEASE) /* Stable release state */       \ STATUS(KS_PRESS_SHAKE) /* Press jitter status */       \ STATUS(KS_PRESS) /* Steady press state */       \ STATUS(KS_RELEASE_SHAKE) /* Release the jitter state */       \ STATUS(KS_NUM) /* The total number of States ( Invalid state )*/  \ typedefenum{

KEY_STATUS_ENUM(ENUM_ITEM)}KEY_STATUS;constchar*key_status_name[]={

KEY_STATUS_ENUM(ENUM_STRING)};

Macro definitions are difficult to understand , Macro definitions can be brought into , To the final result , Understand the specific form after replacement , For example, the following macro definitions are used to carry in the replacement diagram ：

/*KEY_STATUS_ENUM(STATUS) --> STATUS(KS_RELEASE) ... STATUS(KS_NUM)KEY_STATUS_ENUM(ENUM_ITEM)--> ENUM_ITEM(KS_RELEASE) ... ENUM_ITEM(KS_NUM)--> KS_RELEASE, ... KS_NUM,KEY_STATUS_ENUM(ENUM_STRING)--> ENUM_STRING(KS_RELEASE) ... ENUM_STRING(KS_NUM)--> #KS_RELEASE, ... #KS_NUM,*/

2.2.2 State machine implementation

The following is the implementation of the state machine ：

· State machine function key_status_check In a cycle , Every 10ms Call once

· Define a g_keyStatus Indicates the state of the state machine

· In each cycle ,switch According to the current state , Execute the logic required by the corresponding state

· Define a g_DebounceCnt It is used to calculate the buffeting time , When it continues to enter the de chattering state , Each cycle (10ms) Add... To this value 1, Last for a certain number of times (5 Time , namely 50ms), Press or release considered stable , Buffeting complete , Jump to stable direction or stable release state

· In the execution logic of each state , When it is detected that certain conditions are met , Jump to another state

· Through the continuous jump of state , Realize the running of state machine

· Besides , For the convenience of observing the change of state in the state machine , Defined a g_lastKeyStatus Indicates the previous status , When the state changes , You can print out the status name

KEY_STATUSg_keyStatus=KS_RELEASE;// The status of the current key KEY_STATUSg_lastKeyStatus=KS_NUM;// Last state intg_DebounceCnt=0;// Buffeting time count voidkey_status_check(){

switch(g_keyStatus)

{

// Key release ( The initial state )caseKS_RELEASE:

{

// Low level detected , First, eliminate the chattering if(KEY0==0)

{

g_keyStatus=KS_PRESS_SHAKE;

g_DebounceCnt=0;

}

}

break;

// Press jitter caseKS_PRESS_SHAKE:

{

g_DebounceCnt++;

// It's really jittery if(KEY0==1)

{

g_keyStatus=KS_RELEASE;

}

// Buffeting complete elseif(g_DebounceCnt==5)

{

g_keyStatus=KS_PRESS;

printf("=====> key press\r\n");

}

}

break;

// Press steadily caseKS_PRESS:

{

// High level detected , First, eliminate the chattering if(KEY0==1)

{

g_keyStatus=KS_RELEASE_SHAKE;

g_DebounceCnt=0;

}

}

break;

// Release the jitter caseKS_RELEASE_SHAKE:

{

g_DebounceCnt++;

// It's really jittery if(KEY0==0)

{

g_keyStatus=KS_PRESS;

}

// Buffeting complete elseif(g_DebounceCnt==5)

{

g_keyStatus=KS_RELEASE;

printf("=====> key release\r\n");

}

}

break;

default:break;

}

if(g_keyStatus!=g_lastKeyStatus)

{

g_lastKeyStatus=g_keyStatus;

printf("new key status:%d(%s)\r\n",g_keyStatus,key_status_name[g_keyStatus]);

}}intmain(void){

delay_init();// Delay function initialization KEY_Init();

uart_init(115200);

printf("hello\r\n");

while(1)

{

key_status_check();

delay_ms(10);

}}

notes ： This routine requires the use of a key , You need to initialize the corresponding GPIO, No more code here .

2.3 Use tests

Compile and burn the complete code into the board , Connect the serial port , Press and release the key , Observe the serial port output information .

My test output information is as follows ：

The first two toggles the button to simulate the shaking of the button , You can see that the serial port prints two state switches from release to press jitter .

Then press the key , Release the button again , You can see the change of state ： Release  -> Press jitter  -> Press down  -> Release the jitter  -> Release

3 summary

This paper introduces the programming implementation of state machine commonly used in embedded software development , And by pressing the key to eliminate the shaking instance , In common use switch-case form , The corresponding state machine programming code is implemented , And pass the test , Serial port print corresponding status , Analyze the state jump process of the state machine .