什么是状态
6 n; F$ I4 M% r- g6 Z5 o* i, k状态是人或事物表现出来的形态。是指现实（或虚拟）事物处于生成、生存、发展、消亡时期或各转化临界点时的形态或事物态势。
$ d- {- z1 @. @4 T# G5 ~) E& x' f
0 |+ X2 m, _! G  M  L通过上面那句话，我们知道了状态就是一个对象在不同情况下对应的各种形态
& [7 u- ~0 n2 I0 k9 h( K
做产品的时候，如果我们如果要对这个对象所有的形态进行描述，在一些对象复杂的逻辑状态下，比较复杂的逻辑问题，普通的流程图，或时序图对于对象和状态的解读缺乏直观的描述。
; ^: ^! R/ {; \9 g% H6 x6 C
这个时候就需要状态机来对对象的各个形态进行描述，将对象的全部工作方式，分成几个场景，这些场景的工作方式不同，然后将这些场景通过数学模型表示出来
. B9 G2 A$ v% h9 g2 _1 y
: ]( U/ u3 \1 l4 v9 F比方说一个小灯泡的开关，就是一个最基本的小型状态机

% V- j  W6 @$ r0 W+ ~5 d
0 Q- g4 S6 i/ `5 h8 S1 u这里就是两个状态：①打开开关，灯泡亮，②关闭开关，灯泡灭

: A5 {: M7 X& w; t' [( s对应的状态机图：


; S: Q9 b. q9 ~" S4 x2 |2 Y
( Z) Z) C4 v0 b' [6 ?* {这就是最简单的一个状态机
; m" y( c  d5 b6 @
: h; g! Y9 P0 u2 c% k' d  d状态机方便的地方是，如果现在我们只有两种状态，这两个状态在 打开开关/关闭开关两个条件之间跳转，如果我们要加上一个新的条件，比方说我们设定了定时开关灯，多了一个跳转条件，如果灯泡开了超过8个小时就自动关闭，除非再次做打开开关，否则灯泡一致处于关闭状态，这个状态图如下：
. ?# m& ?: [% Z& p' [# f


是不是很方便

1 O8 S! S: c; P! h1 ?0 |9 {' n0 y再举个最简单的例子。人有三个状态健康，感冒，康复中。
+ |* ?& t. }8 ~, T8 P7 h$ E6 U触发的条件有淋雨(t1)，吃药(t2)，打针(t3)，休息(t4)。
& z1 o% j0 |' u# L所以状态机就是健康->(t4)->健康;健康->(t1)->感冒;感冒->(t3)->健康;感冒->(t2)->康复中;康复中->(t4)->健康，等等。就是这样状态在不同的条件下跳转到自己或不同状态的情况，就叫做状态机。

状态机要素
- S6 T/ {" R( K6 C6 Q5 J& v通过上面的举例，我们可以讲状态机可归纳为4个要素，即现态、条件、动作、次态。这样的归纳，主要是出于对状态机的内在因果关系的考虑。“现态”和“条件”是因，“动作”和“次态”是果。详解如下：
: T! Y2 I" v1 \# ^3 @/ `
$ b. ?* I% `& C4 ]) O9 p①现态：是指当前所处的状态。
. ~/ b- [( G2 X
②条件：又称为“事件”，当一个条件被满足，将会触发一个动作，或者执行一次状态的迁移。

- [) R3 z' ?: J. K③动作：条件满足后执行的动作。动作执行完毕后，可以迁移到新的状态，也可以仍旧保持原状态。动作不是必需的，当条件满足后，也可以不执行任何动作，直接迁移到新状态。

④次态：条件满足后要迁往的新状态。“次态”是相对于“现态”而言的，“次态”一旦被激活，就转变成新的“现态”了。
* X* n( ?# M3 B, W2 D5 A
状态机是一种编程思路。是现实事物运行规则抽象而成的一个数学模型。

有限状态机
, U0 d5 n& u( N$ p+ G有限状态机简称就是状态机，因为一般的状态机的状态都是离散和可举的，即为有限，所以后面的介绍都不加有限二字**。状态机表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型**。通俗的描述状态机就是定义了一套状态変更的流程：
7 ?* |+ E0 K/ v. i' D' x
状态机包含一个状态集合，定义当状态机处于某一个状态的时候它所能接收的事件以及可执行的行为，执行完成后，状态机所处的状态。

状态迁移图（STD）


9 m# Q, z+ J) z$ a4 u; s) L7 A（1）状态框：用方框表示状态，包括所谓的“现态”和“次态”；
" I7 X. F9 i- H) _（2）条件及迁移箭头：用箭头表示状态迁移的方向，并在该箭头上标注触发条件；
（3）节点圆圈：当多个箭头指向一个状态时，可以用节点符号（小圆圈）连接汇总；
" A- y7 S( I9 O/ ~+ p+ ]& [, d4 }3 z（4）动作框：用椭圆框表示；
（5）附加条件判断框：用六角菱形框表示；
  O7 y5 A+ Y% Q$ W
状态表：

- k$ p7 i3 N" K0 w. G$ X. `. C

1 B3 O& q7 U" T5 W' \STM32中的状态机
' y& \! }/ v0 n) B举个简单的例子：就按键处理来说，按键动作本身也可以看做一个状态机。一个细小的击键动作包含了：释放、抖动、按下、抖动和重新释放等状态。　　当我们打开思路，把状态机作为一种思想导入到程序中去时，就会找到处理疑问的一条有效的捷径。有时候用状态机的思维去思考程序该干什么，比用控制流程的思维去思考，可能会更有效。这样一来状态机便有了更实际的功用。废话不多说，实践才是检验真理的唯一标准。

也许有人觉得状态机把问题复杂化了，其实我们在编写代码的时候在无形之中已经使用了状态机的思想，比方说我们的if else 判断

if else语句结构状态机

1. if 条件1
   ) Y, w5 P5 T) J; C1 k( Y: |- i2 }
2. 
   
3. else if  条件2
   
4. 
   / F5 s* V' o, N9 b% {7 N
5. else if   条件3
   
6. 
   
7. ...
   - N8 ~/ u1 @, U% o$ w, r* L$ }
8. 
   7 d9 v( K, y. W) j1 a
9. else  条件n
   

复制代码

我们知道C语言的if else if语句是从第一条开始判断的，如果符合条件的那一行永远在后面几行，那么就要每次多执行很多次的if …而if是判断语句，括号内的判断是要执行运算的，即使是单周期指令的MCU，在进行乘除运算等都需要消耗多个时钟周期，因此，每次多执行1次判断至少浪费一个时钟周期甚至更多，因此，这样子的状态机无疑是效率低下的，系统软件设计会很复杂。
; l; b5 A) ~/ c2 i
# R0 b9 W1 U* |switch case结构状态机
. g! Y6 L, L4 `: B& ?% ~

1. 　switch()。
   
2. 
   
3. 　　case1:。
   8 h$ X2 u& |7 L1 w& B
4. 
   
5. 　　if(not反复执行状态1)。
   
6. 
   0 a$ G4 i3 I# f; v; {' X! ]- i  g8 U# ?
7. 　　进入1状态前要做的准备。
     n1 r$ ]( X0 M* b. E* h+ g# o/ }
8. 
   
9. 　　进入1状态的过程。
   * B3 t8 Y3 T* W1 j
10. 
    ( \- Q% _% J6 u
11. 　　if(not反复执行状态1)。
    
12. 
    
13. 　　离开状态1的过程。
    ( u& ?6 H' I6 L2 F& d
14. 
      J8 [4 ~3 _7 K# ]' i/ i8 C; u
15. 　　case2:。
    
16. 
    
17. 　　...。
    . S' {& W5 u: g9 P$ V# F7 v

复制代码

使用Switch case 相较于if else的好处就是可以清楚的看到所有的状态，然后代码架构更清楚点，但是实际的运行效率还是没有提高
9 K0 l- D" q, h+ Z- I" ]
* q; G% N9 I* o& n% h- \6 e再说一下使用Switch编写状态机的两种写法
5 Z! K. g7 Y! V8 A
  q% j$ a3 P) Q9 x我们假设状态机的状态转换由下表所示：
( @7 y6 `* s( N  ]


当处于State0时发生event0 则执行action0并将状态变成state1，当state1状态下发生event2则执行action6并将状态变成state2。以此类推。

下面描述下实现上述状态机的两种不同的写法：
8 @) V: P9 a  p0 |1）竖着写：在状态中判断事件，并执行相应的操作，完成相应的状态转换。
2）横着写：在事件中根据当前的状态，执行相应的操作，完成相应的状态转换。
; y9 L0 R2 |1 H2 i- @  x) V6 Z
0 N/ {' W0 D8 b: _* j

1. //竖着写
   ) W1 R- w  X1 i( [% G; S
2. switch(cur_state)
   / l$ n" B9 s7 }
3. {
   
4.   case State0:
   
5.          if(event1)
   
6.           {
   
7.              action0;
   ) Z! P) a5 o3 r; v
8.              cur_state = State1;
   $ w) d5 B. |9 I( t  c
9.            }
   
10.           else if(event2)
    # ~2 q/ k4 Z: M; B$ n0 U0 ~3 Q/ y
11.           {
    
12.               action4;
    
13.               cur_state = State1;
    4 A- m/ M, B, Z- V& {
14.           }
    
15.           else if(event3)
    4 \9 y* ?- j8 M7 Q( I
16.           {
    ' @# W7 z: d% X2 p8 d
17.               action5;
    
18.               cur_state = State2;
    9 Z" O) g- n) [3 `
19.           }
    - s7 M# u; C7 d6 E, a% w
20.        break;
    
21.     case State1:
    5 _$ p5 Y1 _/ D1 \. T. d
22.          if(event1)
    
23.           {
    
24.              action1;
    : n' r0 j( N6 ^5 p' J( _- f! m
25.              cur_state = State2;
    
26.            }
    
27.           else if(event3)
    ! X1 r! n  w( ^0 C' k$ D
28.           {
    - n5 ^5 K) }! g# ~* s0 Z
29.               action6;
    
30.               cur_state = State0;
    
31.           }
    0 N  c% J0 x4 n
32.         break;
    ' n6 @- [5 o# R' o' X, [4 r' K
33.      case State2:
    
34.          if(event1)
    
35.           {
    
36.              action3;
    7 g" C0 O* _4 c- M
37.              cur_state = State0;
    
38.            }
    7 L" g, x4 T. H) D) m/ ]
39.         break;
    ; A+ T/ N" j$ y5 v3 h. t% ~
40.      default:break;
    $ n' X; H  O& B+ v1 @
41. }
    

复制代码

1. //横着写
   
2. void event0func(void)
   
3. {
   ; e* x2 z( k$ ^$ k" H: Y
4.     switch(cur_state)
   
5.     {
   
6.         case State0:
   , }+ |; q9 `+ r5 q: K: ~! z- {
7.              action0;
   ) a2 w& _( X' A2 P, Z1 u4 W; s
8.              cur_state = State1;
   , v/ }( u2 C7 c5 o6 \
9.         break;
   
10.          case State1:
      t( f1 m$ W; F& \3 `
11.              action1;
    
12.              cur_state = State2;
    9 v0 Y5 Q* v+ C2 _9 w* K, s) a
13.         break;
    * J* v* _+ I1 _. w; Z: w. q' B. }
14.          case State2:
    ) }9 F) u# w  X' P- C! H
15.              action1;
    
16.              cur_state = State0;
    $ C( {( H- Q  y8 H
17.         break;
    
18.         default:break;
    
19.     }
      P+ |) t* |7 j% f1 y! Y
20. }
    & p( }0 o8 X& M+ P& m, G! E
21. 
    
22. void event1func(void)
    
23. {
    3 ?  h" Y! w+ R% U
24.     switch(cur_state)
    
25.     {
    8 O% ~) H# E, S% U4 c. s
26.         case State0:
    
27.              action4;
    ; g( H! B9 c. S+ O3 }5 N
28.              cur_state = State1;
    
29.         break;
    
30.         default:break;
    
31.     }
    
32. }
    
33. 
    
34. void event2func(void)
    / o- c6 O( Q2 |! x5 f
35. {
    8 d2 d5 q/ l2 S
36.     switch(cur_state)
    
37.     {
    9 s* u: u' _6 K8 o. f
38.         case State0:
    
39.              action5;
    # r' {$ N$ [; ^# ?
40.              cur_state = State2;
    6 |' m" |7 P! N1 f& w5 l$ I
41.         break;
    
42.          case State1:
    
43.              action6;
    
44.              cur_state = State0;
    
45.         break;
    ! v; E7 n/ d6 R
46.         default:break;
    2 r) v6 ^6 G- Z
47.     }
    6 a* M+ E, J& b* E4 n3 h" p3 _
48. }
    
49. 
    
50. 
    

复制代码

" E3 O6 h' Z1 \. T* f上述两种写法实现的功能完全相同，对比两种写法：

9 ~. G) T: n) l& |1）写法1（竖着写）使用了if -else if语句隐含了优先级，破坏可事件间的原有关系（各个时间应该同优先级）
) B6 l3 ^! K8 L. K) U5 j3 z2）写法1（竖着写）在结构上是顺序查询方式（查询事件），浪费大量的时间，而且时间不可估算。
写法2（横着写）因为在某个时间点上状态是唯一确定的，在时间处理函数中通过switch语句可直接定位到相同状态，执行时间也可以估算。
3）写法2（横着写）比较直观，程序执行效率较高。
6 y% g: `+ M; A! g( \. _  H总体来说：写法2要优于写法1。
) z' ~; H3 k6 }/ \& k! N/ H% e
5 k+ k! ^, C; O( l* k但是不论是在事件中判断状态，在状态中判断事件，横竖两种写法的代码都比较冗长，看起来呢也不大好，一旦增减，就又要动脑子重新梳理一遍，实际编写我们并不采用这两种写法
$ v. v; y# |7 n. @————————————————
, R* w1 j% Y2 }版权转载自：Z小旋
8 |- d8 W' j# \% y+ ~7 u
5 ]' M: v9 `; P* ]
9 f1 Q. ^: G. ?0 b