0
  • 聊天消息
  • 系统消息
  • 评论与回复
登录后你可以
  • 下载海量资料
  • 学习在线课程
  • 观看技术视频
  • 写文章/发帖/加入社区
创作中心

完善资料让更多小伙伴认识你,还能领取20积分哦,立即完善>

3天内不再提示

状态机编程实例-状态表法

码农爱学习 来源:码农爱学习 作者:码农爱学习 2023-06-20 09:05 次阅读

上篇文章,使用嵌套switch-case法的状态机编程,实现了一个炸弹拆除小游戏。

本篇,继续介绍状态机编程的第二种方法:状态表法,来实现炸弹拆除小游戏的状态机编程。

1 状态表法

状态表法,顾名思义,就是通过一个状态表,来实现状态机中的状态转换,下面就先介绍下状态表的基础知识。

1.1 状态表

状态表 ,最常用的是使用一个2维状态表:

  • 水平方向是各个事件
  • 竖直方向是各个状态
  • 单元的内容是通过(执行动作,下一状态)来表示各种转换关系

结合上一篇设计炸弹拆除小游戏的状态图(2个状态和4个事件):

可以设计出对应的状态表,如下图:

  • 水平方向的4种事件:UP、DOWN和ARM按键事件,TICK事件
  • 竖直方向的2种状态:设置状态和倒计时状态
  • 单元的内容表示执行指定动作后,下一状态是什么。比如设置状态时按下UP键,执行setting_UP函数中的动作后,下一状态还是留在设置状态

注意:

  • (*):仅当(me->code == me->defuse),即密码输入正确时,才进行状态转换至“设置状态”
  • ):仅当(me->fine_time == 0)和(me->timeout != 0),即每过一秒且倒计时未减到0时,才进行状态转换至“倒计时状态”**

1.2 事件处理器

由于状态表法可以使用一个非常有规律的数据结构(状态表)来表现一个状态机,因此编程时可以编写一个通用的“事件处理器”来实现状态机功能。

如下图,通用的状态表事件处理器,包含两个主要结构:

  • 一个外部转换的StateTable结构
  • 一个带有事件参数和没有事件参数的Event结构

此外,StateTable结构有两个相关的函数:

  • init()函数用于触发状态机的初始转换
  • dispatch()函数用于派送一个事件给状态机处理

需体会的是,StateTable结构是一个抽象的结构,按照UML类图的画法,这是一个抽象类(使用《abstract》或斜体类名表示),需要通过派生出一个实例类,如图中的Bomb2,来实现具体的业务功能。

在状态机的应用程序中,状态表仅包含执行转换函数的指针,即函数指针,而不是(执行动作,下一状态)的形式,使用这种方式,实际就是把状态改变的逻辑,放到了转换函数中,这样做,使得编程更加灵活,因为状态函数能方便地判断某些监护条件并随之改变。

2 状态表法的实现

上面介绍了状态表法的基础知识,下面就来通过代码来介绍状态表法的具体实现。

2.1 通用状态表事件处理器

上面说到,状态表法可以使用一个非常有规律的状态表数据结构来表现一个状态机,因而在程序设计时,可以编写一个通用的状态表事件处理器。

2.1.1 接口定义

通用的状态表事件处理器,先来通过接口定义,看下它的功能。

注意上面提到的它包含两个主要结构:

  • 一个外部转换的StateTable结构
  • 一个带有事件参数和没有事件参数的Event结构

以及StateTable结构的两个相关的函数:

  • init()函数:用于触发状态机的初始转换
  • dispatch()函数:用于派送一个事件给状态机处理
// 用于进行状态转换的宏
#define TRAN(target) (((StateTable *)me)- >state = (uint8_t)(target))typedef struct EventTag
{
  uint16_t sig; // 事件的信号
} Event;
​
struct StateTableTag; //提前声明此变量// 函数指针
typedef void (*Tran)(struct StateTableTag *me, Event const *e);
​
// 状态表数据结构
typedef struct StateTableTag
{
  uint8_t state;           //当前状态
  Tran const *state_table; //状态表
  uint8_t n_states;        //状态的个数
  uint8_t n_signals;       //事件(信号)的个数
  Tran initial;            //初始转换
} StateTable;
​
void StateTable_ctor(StateTable *me, Tran const *table, uint8_t n_states, uint8_t n_signals, Tran initial);
void StateTable_init(StateTable *me);
void StateTable_dispatch(StateTable *me, Event const *e);
void StateTable_empty(StateTable *me, Event const *e);

StateTable_ctor是状态表的“构造函数”,仅指向一个基本的初始化动作,不会触发初始转换。

StateTable_empty是一个默认的空动作,用于状态表初始化时,某些需要空单元的地方使用。

另外,这里还要体会函数指针的用法。什么是函数指针,下面再来复习一下。

2.1.2 体会函数指针的用法

函数指针,本质是一个指针,其指向的一个函数,其类型定义为:

返回值类型 (* 函数名) ([形参列表]);

注意和指针函数的区别:

何为指针函数?

*指针函数,本质是一个函数,例如 int pfun(int, int); 其返回值是指针类型,即返回一个指针(或称地址),这个指针指向的数据是什么类型都可以。

一个记忆小技巧:指针函数,可以类比int函数,它们都是函数,只是返回值不一样,一个是返回指针,一个返回int。

首先来看函数指针的定义,以及基础用法:

//定义一个函数指针pFUN,它指向一个返回类型为void,有一个参数类型为int的函数
void (*pFun)(int);
​
//定义一个返回类型为void,参数为int的函数。从指针层面上理解该函数,其函数名实际上是一个指针,该指针指向函数在内存中的首地址
void glFun(int a)
{
    printf("%d
", a);
}
​
int main()
{
    pFun = glFun; //将函数glFun的地址赋值给变量pFun
    (*pFun)(2);//“*pFun”是取pFun所指向地址的内容,即取出了函数glFun()的内容,然后给定参数为2
    
    return 0;
}

实际使用时,常常通过typedef的方式让函数指针更直观方便的进行使用:

//定义新的类型PTRFUN, 此类型的实际含义为函数指针,指向的函数的返回值是void,参数是int
typedef void (*PTRFUN)(int); 
​
//定义一个返回类型为void,参数为int的函数
void glFun(int a)
{ 
    printf("%d
", a);
} 
​
int main() 
{ 
    PTRFUN pFun; //使用定义的(函数指针)类型,实例化一个函数指针
    
    pFun = glFun; //把定义的glFun函数,以函数名(本质即指针)的形式为其赋值
    (*pFun)(2); //执行该函数指针指向的内容,即指向指向的函数,并指定参数2
    
    return 0;
}

关于函数指针的实际应用,也可参考我之前的这篇文章: STM32简易多级菜单(数组查表法)

2.1.3 具体实现

看完了通用的状态表事件处理器的接口定义,下面再来看下具体实现。

//状态表的构造
void StateTable_ctor(StateTable *me,
                     Tran const *table, uint8_t n_states, uint8_t n_signals,
                     Tran initial)
{
    //第一个参数me为StateTable结构,由具体业务的派生状态表的tateTable结构传入
    me- >state_table = table;   //状态表, 由具体业务的二维状态表传入
    me- >n_states = n_states;   //二维状态表的状态数量
    me- >n_signals = n_signals; //二维状态表的信号(事件)数量
    me- >initial = initial;     //状态表的初始准换函数
}
​
//状态表的初始化
void StateTable_init(StateTable *me)
{
    me- >state = me- >n_states;
    (*me- >initial)(me, (Event *)0); //初始转换
​
    assert(me- >state < me- >n_states); //确保事件范围的合理
}
​
//状态表的调度(派送一个事件给状态机处理)
void StateTable_dispatch(StateTable *me, Event const *e)
{
    Tran t;
​
    assert(e- >sig < me- >n_signals); //确保信号范围的合理//通过当前状态与当前的信号,以及信号的总数,计算得到状态表中要执行的转换函数在状态表(二维的函数指针数组)中的位置
    t = me- >state_table[me- >state * me- >n_signals + e- >sig];
    (*t)(me, e); //然后执行转换函数
​
    assert(me- >state < me- >n_states); //确保状态范围的合理
}
​
//状态表的空元素
void StateTable_empty(StateTable *me, Event const *e)
{
    (void)me; //用于消除参数未使用的警告
    (void)e;  
}

这里要体会一下状态表的调度,即派送一个事件给状态机处理的代码逻辑,StateTable_dispatch的两个参数,一个是StateTable结构的二维表,一个是Event结构的信号(事件),注意这个二维状态表,存储的函数指针(各种转换函数),所以是一个二维的函数指针数组,根据信号,如何知道要执行二维数组中的哪个函数呢?还要借助当前状态机所处的状态,即可通过简单的数学运算得出,示意如下图:

2.2 应用逻辑(具体业务代码)

看完了通用的状态表事件处理器,就可以在此基础上,编写具体的状态机业务代码,实现上一篇介绍的炸弹拆除小游戏。

2.2.1 接口定义

还是先看下炸弹拆除小游戏这个具体业务逻辑用到的数据结构与接口定义,主要包括:

  • 炸弹状态机的状态与信号(事件)
  • 从状态表事件处理器的Event结构派生的带有事件参数的TickEvt结构
  • 从状态表事件处理器的StateTable结构派生的具体的炸弹状态机数据结构
  • 状态表中用到的所有的转换函数
// 炸弹状态机的所有状态
enum BombStates
{
  SETTING_STATE, // 设置状态
  TIMING_STATE,   // 倒计时状态
  STATE_MAX
};
​
// 炸弹状态机的所有信号(事件)
enum BombSignals
{
  UP_SIG,   // UP键信号
  DOWN_SIG, // DOWN键信号
  ARM_SIG,  // ARM键信号
  TICK_SIG,  // Tick节拍信号
  SIG_MAX
};
​
typedef struct TickEvtTag
{
  Event super;       // 派生自Event结构
  uint8_t fine_time; // 精细的1/10秒计数器
} TickEvt;
​
// 炸弹状态机数据结构
typedef struct Bomb2Tag
{
  StateTable super; // 派生自StateTable结构
  uint8_t timeout; // 爆炸前的秒数
  uint8_t code;    // 当前输入的解除炸弹的密码
  uint8_t defuse;  // 解除炸弹的拆除密码
  uint8_t errcnt;  // 当前拆除失败的次数
} Bomb2;
​
//炸弹构造
void Bomb2_ctor(Bomb2 *me, uint8_t defuse);
//状态表中需要用到的转换函数(函数指针)
void Bomb2_initial(Bomb2 *me, Event const *e);      //初始转换
void Bomb2_setting_UP(Bomb2 *me, Event const *e);   //转换函数, 设置状态时, 处理UP事件
void Bomb2_setting_DOWN(Bomb2 *me, Event const *e); //转换函数, 设置状态时, 处理DOWN事件
void Bomb2_setting_ARM(Bomb2 *me, Event const *e);  //转换函数, 设置状态时, 处理ARM事件
void Bomb2_timing_UP(Bomb2 *me, Event const *e);    //转换函数, 倒计时状态时, 处理UP事件
void Bomb2_timing_DOWN(Bomb2 *me, Event const *e);  //转换函数, 倒计时状态时, 处理DOWN事件
void Bomb2_timing_ARM(Bomb2 *me, Event const *e);   //转换函数, 倒计时状态时, 处理ARM事件
void Bomb2_timing_TICK(Bomb2 *me, Event const *e);  //转换函数, 倒计时状态时, 处理Tick事件

2.2.2 具体实现

1)炸弹构造与初始化

炸弹构造与初始化的实现如下

//炸弹构造
void Bomb2_ctor(Bomb2 *me, uint8_t defuse)
{
  //定义炸弹状态机的状态表(函数指针构成的二维数组)
  static const Tran bomb2_state_table[STATE_MAX][SIG_MAX] = {
    {(Tran)&Bomb2_setting_UP, (Tran)&Bomb2_setting_DOWN, (Tran)&Bomb2_setting_ARM, &StateTable_empty},
    {(Tran)&Bomb2_timing_UP, (Tran)&Bomb2_timing_DOWN, (Tran)&Bomb2_timing_ARM, (Tran)&Bomb2_timing_TICK}
  };
​
  //使用通用的通用状态表事件处理器构造状态表
  StateTable_ctor(&me- >super, &bomb2_state_table[0][0], STATE_MAX, SIG_MAX, (Tran)&Bomb2_initial); 
  me- >defuse = defuse; //设置默认的拆除密码
}
​
//炸弹初始化
void Bomb2_initial(Bomb2 *me, Event const *e)
{
  (void)e; //用于消除参数未使用的警告
  me- >timeout = INIT_TIMEOUT;
  me- >errcnt = 0;
  TRAN(SETTING_STATE); //默认进行设置状态
}

2)各个转换函数

各个转换函数(函数指针)的具体实现如下,其特征为短函数

/*.................设置状态下的事件处理函数......................*/
void Bomb2_setting_UP(Bomb2 *me, Event const *e)
{
  (void)e; /* avoid compiler warning about unused parameter */
  if (me- >timeout < 60)
  {
    ++me- >timeout; //设置超时时间+1
    bsp_display_set_time(me- >timeout); //显示设置的超时时间
  }
}
​
void Bomb2_setting_DOWN(Bomb2 *me, Event const *e)
{
  (void)e; /* avoid compiler warning about unused parameter */
  if (me- >timeout > 1)
  {
    --me- >timeout; //设置超时时间-1
    bsp_display_set_time(me- >timeout); //显示设置的超时时间
  }
}
​
void Bomb2_setting_ARM(Bomb2 *me, Event const *e)
{
  (void)e; /* avoid compiler warning about unused parameter */
  me- >code = 0;
  TRAN(TIMING_STATE); /* transition to "timing" */
}
​
/*...................倒计时状态下的事件处理函数................*/
void Bomb2_timing_UP(Bomb2 *me, Event const *e)
{
  (void)e; /* avoid compiler warning about unused parameter */
  me- >code < <= 1;
  me- >code |= 1; //添加一个1
  bsp_display_user_code(me- >code);
}
​
void Bomb2_timing_DOWN(Bomb2 *me, Event const *e)
{
  (void)e; /* avoid compiler warning about unused parameter */
  me- >code < <= 1; //添加一个0
  bsp_display_user_code(me- >code);
}
​
void Bomb2_timing_ARM(Bomb2 *me, Event const *e)
{
  (void)e; /* avoid compiler warning about unused parameter */
  if (me- >code == me- >defuse)
  {
    TRAN(SETTING_STATE); //转换到设置状态
    bsp_display_user_success(); //炸弹拆除成功
    Event *e = NULL;
    Bomb2_initial(me, e);
  }
  else
  {
    me- >code = 0;
    bsp_display_user_code(me- >code);
    bsp_display_user_err(++me- >errcnt);
  }
}
​
void Bomb2_timing_TICK(Bomb2 *me, Event const *e)
{
  if (((TickEvt const *)e)- >fine_time == 0)
  {
    --me- >timeout;
    bsp_display_remain_time(me- >timeout);
    if (me- >timeout == 0)
    {
      bsp_display_bomb(); //显示爆炸效果
      Event *e = NULL;
      Bomb2_initial(me, e);
    }
  }
}

2.3 主函数

本篇同样使用Arduino控制器进行测试,对应的主函数代码如下:

static Bomb2 l_bomb;
​
void setup(void)
{
  Serial.begin(115200);
  bsp_display_init();
  bsp_display_hello();
  bsp_key_init();
​
  Bomb2_ctor(&l_bomb, 0x0D); // 构造, 密码1101
  StateTable_init((StateTable *)&l_bomb); // 初始转化
}
​
void loop(void)
{
  static TickEvt tick_evt = {TICK_SIG, 0};
  delay(100);
​
  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) ? '
' : ' ');
  Serial.print(tmp_buffer);
​
  StateTable_dispatch((StateTable *)&l_bomb, (Event *)&tick_evt);
​
  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)
    {
      case UP_SIG: //UP键事件
      {
        Serial.print("
UP  : ");
        e = &up_evt;
        break;
      }
      case DOWN_SIG: //DOWN键事件
      {
        Serial.print("
DOWN: ");
        e = &down_evt;
        break;
      }
      case ARM_SIG: //ARM键事件
      {
        Serial.print("
ARM : ");
        e = &arm_evt;
        break;
      }
      default:break;
    }
​
    /* keyboard event available? */
    if (e != (Event *)0)
    {
       StateTable_dispatch((StateTable *)&l_bomb, e); /* dispatch the event */
    }
  }
}

3 总结

本编介绍了状态机编程的第2种方法——状态表法,通过一个非常有规律的二维表数据结构,以及函数指针,实现炸弹拆除小游戏中的状态机功能。

本篇,需要重点体会的点包括:

  • 通用的“事件处理器”的结构与功能
  • 函数指针的妙用,一般与数组查表法结合
  • 根据实际的状态转换与处理的业务需求,利用状态表法,实现状态机编程

    审核编辑:汤梓红
声明:本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人,不代表电子发烧友网立场。文章及其配图仅供工程师学习之用,如有内容侵权或者其他违规问题,请联系本站处理。 举报投诉
  • 嵌入式
    +关注

    关注

    4981

    文章

    18263

    浏览量

    288160
  • 编程
    +关注

    关注

    88

    文章

    3439

    浏览量

    92368
  • 状态机
    +关注

    关注

    2

    文章

    485

    浏览量

    27158
  • 函数指针
    +关注

    关注

    2

    文章

    53

    浏览量

    3735
收藏 人收藏

    评论

    相关推荐

    Verilog状态机+设计实例

    在verilog中状态机的一种很常用的逻辑结构,学习和理解状态机的运行规律能够帮助我们更好地书写代码,同时作为一种思想方法,在别的代码设计中也会有所帮助。 一、简介 在使用过程中我们常说
    的头像 发表于 02-12 19:07 1969次阅读
    Verilog<b class='flag-5'>状态机</b>+设计<b class='flag-5'>实例</b>

    状态机该怎么监控

    状态机卡住的场景——通过状态跳转条件的DFX信号去判断卡住的原因
    的头像 发表于 01-15 10:03 168次阅读
    <b class='flag-5'>状态机</b>该怎么监控

    Spring状态机的实现原理和使用方法

    说起 Spring 状态机,大家很容易联想到这个状态机和设计模式中状态模式的区别是啥呢?没错,Spring 状态机就是状态模式的一种实现,在
    的头像 发表于 12-26 09:39 938次阅读
    Spring<b class='flag-5'>状态机</b>的实现原理和使用方法

    SaberRD状态机建模工具介绍(一)什么是状态机建模

    状态机建模是使用状态图和方程式的手段,创建基于混合信号的有限状态机模型的一种建模工具。
    的头像 发表于 12-05 09:51 513次阅读
    SaberRD<b class='flag-5'>状态机</b>建模工具介绍(一)什么是<b class='flag-5'>状态机</b>建模

    什么是状态机状态机的种类与实现

    状态机,又称有限状态机(Finite State Machine,FSM)或米利状态机(Mealy Machine),是一种描述系统状态变化的模型。在芯片设计中,
    的头像 发表于 10-19 10:27 4822次阅读

    有限状态机分割设计

    有限状态机分割设计,其实质就是一个状态机分割成多个状态机
    的头像 发表于 10-09 10:47 346次阅读

    什么是有限状态机?有限状态机的四要素介绍

    如果一个对象(系统或机器),由若干个状态构成,在某种条件下触发这些状态,会发生状态相互转移的事件,那么此对象称之为状态机
    的头像 发表于 09-17 16:42 1690次阅读

    如何使用FSME来定制状态机

    定制状态机 目前得到的状态机已经能够响应来自外部的各种事件,并适当地调整自己当前所处的状态,也就是说已经实现了状态机引擎的功能,接下来要做的就是根据应用的具体需求来进行定制,为
    的头像 发表于 09-13 16:57 874次阅读
    如何使用FSME来定制<b class='flag-5'>状态机</b>

    如何生成状态机框架

    生成状态机框架 使用FSME不仅能够进行可视化的状态机建模,更重要的是它还可以根据得到的模型自动生成用C++或者Python实现的状态机框架。首先在FSME界面左边的树形列表中选择"Root
    的头像 发表于 09-13 16:54 649次阅读
    如何生成<b class='flag-5'>状态机</b>框架

    自动生成程序状态机代码状态机建模方法

    首先运行fsme命令来启动状态机编辑器,然后单击工具栏上的“New”按钮来创建一个新的状态机。FSME中用于构建状态机的基本元素一共有五种:事件(Event)、输入(Input)、输出(Output
    的头像 发表于 09-13 16:50 719次阅读
    自动生成程序<b class='flag-5'>状态机</b>代码<b class='flag-5'>状态机</b>建模方法

    基于C语言的状态机实现方案

    关于状态机,基础的知识点可以自行理解。本文主要讲解的是一个有限状态机FSM通用的写法,目的在于更好理解,移植,节省代码阅读与调试时间,体现出编程之美。
    发表于 09-13 09:28 299次阅读
    基于C语言的<b class='flag-5'>状态机</b>实现方案

    状态机编程实例-面向对象的状态设计模式

    本编介绍了状态机编程的第3种方法——面向对象的状态设计模式,通过C++的继承特性,以及类指针,实现炸弹拆除小游戏中的状态机功能。
    的头像 发表于 06-28 09:04 900次阅读
    <b class='flag-5'>状态机</b><b class='flag-5'>编程</b><b class='flag-5'>实例</b>-面向对象的<b class='flag-5'>状态</b>设计模式

    状态机要实现哪些内容

    状态机模式是一种行为模式,通过多态实现不同状态的调转行为的确是一种很好的方法,只可惜在嵌入式环境下,有时只能写纯C代码,并且还需要考虑代码的重入和多任务请求跳转等情形,因此实现起来着实需要一番考虑
    的头像 发表于 06-22 14:26 445次阅读
    <b class='flag-5'>状态机</b>要实现哪些内容

    状态机编程实例-嵌套switch-case法

    嵌入式软件开发中,状态机编程是一个比较实用的代码实现方式,特别适用于事件驱动的系统。本篇,以一个炸弹拆除的小游戏为例,介绍状态机编程的思路。
    的头像 发表于 06-15 09:01 1166次阅读
    <b class='flag-5'>状态机</b><b class='flag-5'>编程</b><b class='flag-5'>实例</b>-嵌套switch-case法

    Verilog状态机的类型

    有限状态机(Finite-State Machine,FSM),简称状态机,是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。
    的头像 发表于 06-01 15:23 1307次阅读
    Verilog<b class='flag-5'>状态机</b>的类型