1 状态机实例介绍

1.1 炸弹拆除游戏

如下是一个自制的炸弹拆除小游戏的硬件实物，由3个按键：

UP键：用于游戏开始前设置增加倒计时时间；用于游戏开始后，输入拆除密码“1”
DOWN键：用于游戏开始前设置减小倒计时时间；用于游戏开始后，输入拆除密码“0”
ARM键：用于从设置时间切换到开始游戏；用于输入拆除密码后，确认拆除

还有一个屏幕，用于显示倒计时时间，输入的拆除密码等

游戏的玩法：

游戏开始前，通过UP或DOWN键，设置炸弹拆除的倒计时时间；也可以不设置，使用默认的时间
按下ARM键，进入倒计时状态；此时再通过UP或DOWN键，UP代表1，DOWN代表0，输入拆除密码（正确的密码在程序中设定了，不可修改，如默认是二进制的1101）
再按下ARM键，确认拆除；若密码正确，则拆除成功；若密码错误，可以再次尝试输入密码
在倒计时状态，若倒计时到0时，还没有拆除成功，则显示拆除失败
拆除成功或失败后，会再次回到初始状态，可重新开始玩

1.2 状态图

使用状态机思路进行编程，首先要画出对应的UML状态图，在画图之前，需要先明确此状态机有哪些状态，以及哪些事件。

对于本篇介绍的炸弹拆除小游戏，可以归纳为两个状态：

设置状态（SETTING_STATE）：游戏开始前，通过UP和DOWN键设置此次游戏的超时时间；通过ARM键开始游戏
倒计时状态（TIMING_STATE）：游戏开始后，通过UP和DOWN键输入密码，UP代表1，DOWN代表0；通过ARM键确认拆除

对于事件（或称信号），有3个按键事件，还有一个Tick节拍事件：

UP键信号（UP_SIG）：游戏开始前设置增加倒计时时间；游戏开始后，输入拆除密码“1”
DOWN键信号（DOWN_SIG）：游戏开始前设置减小倒计时时间；游戏开始后，输入拆除密码“0”
ARM键信号（ARM_SIG）：从设置时间切换到开始游戏；输入拆除密码后，确认拆除
Tick节拍信号（TICK_SIG）：用于倒计时的时间递减

1.3 事件表示

对于上述的状态机事件，可以分为两类，一类是按键事件：UP、DOWN和ARM，一类是Tick。对于第一类事件，指需要单一的事件变量即可区分，对于第二类的Tick，由于引入了1/10s的精细时间，所以这个时间还需要一个额外的事件参数表示此次Tick事件的精细时间（fine_time）。

这里再介绍一个编程技巧，通过结构体的继承关系（实际就是嵌套），实现对事件数据结构的设计，如下图：

子图( a)表示TickEvt与Event是继承关系，这是UML类图的画法，关于UML类图的介绍可参考之前的文章:UML简介与类图详解。

子图( b)是这两个结构体的定义，可以看到TickEvt结构体内部的第1个成员，就是Event结构体，第2个成员，用于表示Tick事件的事件参数。

子图( c) 是TickEvt数据结构在内存中的存储示意，先存储的是基类结构体的super实例，也就是Event这个结构体，然后存储的是子类结构的自定义成员，也就是Tick事件的事件参数fine_time。

这两个结构体的定义如下：

typedef struct EventTag
{
    uint16_t sig; // 事件的信号
} Event;

typedef struct TickEvtTag
{
    Event super;       // 派生自Event结构
    uint8_t fine_time; // 精细的1/10秒计数器
} TickEvt;

这样定义的好处是，对于状态机事件调度函数Bomb1_dispatch的参数形式，可以统一使用（Event *）类型，将TickEvt类型传入时，可以取其地址，再转为（Event *）类型，如下面实例代码中loop函数中的使用；而在Bomb1_dispatch函数内部需要处理TICK_SIG事件时，又可以再将（Event *）类型强制转为（TickEvt *）类型，如下面实例代码中Bomb1_dispatch函数中的使用。

//状态机事件调度
void Bomb1_dispatch(Bomb1 *me, Event const *e)
{
    //省略...
    case TICK_SIG: //Tick信号
    {
        if (((TickEvt const *)e)->fine_time == 0)
        {
            --me->timeout;
            bsp_display_remain_time(me->timeout); //显示倒计时时间
            if (me->timeout == 0)
            {
                bsp_display_bomb(); //显示爆炸效果
                Bomb1_init(me);
            }
        }
        break;
    }
    //省略...
}

//状态机循环
void loop(void)
{
  static TickEvt tick_evt = {TICK_SIG, 0};
  delay(100); /*状态机以100ms的循环运行*/

  if (++tick_evt.fine_time == 10)
  {
    tick_evt.fine_time = 0;
  }

  Bomb1_dispatch(&l_bomb, (Event *)&tick_evt); /*调度处理tick事件*/
  //省略...
}

2 switch-case嵌套法

状态图设计好之后，就可以对照着状态图，进行编程实现了。

本篇先使用最简单最容易理解的switch-case方法，来实现状态机编程。

2.1 状态机处理

使用switch-case法实现状态机，一般需要两层switch结构。

2.1.1 第一层switch处理状态

void Bomb1_dispatch(Bomb1 *me, Event const *e)
{
    //第一层switch处理状态
    switch (me->state)
    {
        //设置状态
        case SETTING_STATE:
        {
            //...
            break;
        }
        //倒计时状态
        case TIMING_STATE:
        {
			//...
            break;
        }
    }
}

2.1.2 第二层switch处理事件

这里以状态机处于“设置状态”时，对事件(信号)的处理为例

//设置状态
case SETTING_STATE:
{
    //第二层switch处理事件(信号)
    switch (e->sig)
    {
        //UP按键信号
        case UP_SIG:
        {
            //...
            break;
        }
        //DOWN按键信号
        case DOWN_SIG:
        {
            //...
            break;
        }
        //ARM按键信号
        case ARM_SIG:
        {
            //...
            break;
        }
    }
    break;
}

2.1.3 两层switch-case状态机完整代码

// 用于进行状态转换的宏
#define TRAN(target_) (me->state = (uint8_t)(target_))

//状态机事件调度
void Bomb1_dispatch(Bomb1 *me, Event const *e)
{
  //第一层switch处理状态
  switch (me->state)
  {
    //设置状态
    case SETTING_STATE:
      {
        //第二层switch处理事件(信号)
        switch (e->sig)
        {
          //UP按键信号
          case UP_SIG:
            {
              if (me->timeout < 60)
              {
                ++me->timeout; //设置超时时间+1
                bsp_display_set_time(me->timeout); //显示设置的超时时间
              }
              break;
            }
          //DOWN按键信号
          case DOWN_SIG:
            {
              if (me->timeout > 1)
              {
                --me->timeout; //设置超时时间-1
                bsp_display_set_time(me->timeout); //显示设置的超时时间
              }
              break;
            }
          //ARM按键信号
          case ARM_SIG:
            {
              me->code = 0;
              TRAN(TIMING_STATE); //转换到倒计时状态
              break;
            }
        }
        break;
      }
    //倒计时状态
    case TIMING_STATE:
      {
        switch (e->sig)
        {
          case UP_SIG: //UP按键信号
            {
              me->code <<= 1;
              me->code |= 1; //添加一个1
              bsp_display_user_code(me->code);
              break;
            }
          case DOWN_SIG: //DWON按键信号
            {
              me->code <<= 1; //添加一个0
              bsp_display_user_code(me->code);
              break;
            }
          case ARM_SIG: //ARM按键信号
            {
              if (me->code == me->defuse)
              {
                TRAN(SETTING_STATE); //转换到设置状态
                bsp_display_user_success(); //炸弹拆除成功
                Bomb1_init(me);
              }
              else
              {
                me->code = 0;
                bsp_display_user_code(me->code);
                bsp_display_user_err(++me->errcnt);
              }
              break;
            }
          case TICK_SIG: //Tick信号
            {
              if (((TickEvt const *)e)->fine_time == 0)
              {
                --me->timeout;
                bsp_display_remain_time(me->timeout); //显示倒计时时间
                if (me->timeout == 0)
                {
                  bsp_display_bomb(); //显示爆炸效果
                  Bomb1_init(me);
                }
              }
              break;
            }
        }
        break;
      }
  }
}

2.2 主函数

两层switch-case状态机逻辑编写好之后，还需要将状态机运行起来。

运行状态机的本质，就是周期性的调用状态机（上面实现的两层switch-case），当有事件触发时，设置对应的事件，状态机在运行时，即可处理对应的事件，从而实现状态的切换，或是其它的逻辑处理。

2.2.1 状态机的运行

状态机运行的整体逻辑如下：

void loop(void)
{
  static TickEvt tick_evt = {TICK_SIG, 0};
  delay(100); /*状态机以100ms的循环运行*/

  if (++tick_evt.fine_time == 10)
  {
    tick_evt.fine_time = 0;
  }

  char tmp_buffer[256];
  sprintf(tmp_buffer, "T(%1d)%c", tick_evt.fine_time, (tick_evt.fine_time == 0) ? '\n' : ' ');
  Serial.print(tmp_buffer);

  Bomb1_dispatch(&l_bomb, (Event *)&tick_evt); /*调度处理tick事件*/

  BombSignals userSignal = bsp_key_check_signal();
  if (userSignal != SIG_MAX)
  {
    static Event const up_evt = {UP_SIG};
    static Event const down_evt = {DOWN_SIG};
    static Event const arm_evt = {ARM_SIG};
    Event const *e = (Event *)0;

    switch (userSignal)
    {
      //监测按键是否按下, 按下则设置对应的事件e
    }

    if (e != (Event *)0) /*有指定的按键按下*/
    {
      Bomb1_dispatch(&l_bomb, e);  /*调度处理按键事件*/
    }
  }
}

2.2.2 事件的触发

在状态机的每个状态循环执行前，都检测一下是否有事件触发，本例中就是UP、DOWN和ARM的按键事件，另外Tick事件是周期性的触发的。UP、DOWN和ARM的按键事件的触发检测代码如下，检测到对应的按键事件后，则设置对应的事件给状态机，状态机即可在下次状态循环中进行处理。

switch (userSignal)
{
    case UP_SIG: //UP键事件
        {
            Serial.print("\nUP  : ");
            e = &up_evt;
            break;
        }
    case DOWN_SIG: //DOWN键事件
        {
            Serial.print("\nDOWN: ");
            e = &down_evt;
            break;
        }
    case ARM_SIG: //ARM键事件
        {
            Serial.print("\nARM : ");
            e = &arm_evt;
            break;
        }
    default:break;
}