基于C语言的最优HSM状态机架构实现

[导读]关注、星标公众号，直达精彩内容来源：小鱼儿飞丫飞整理：技术让梦想更伟大|李肖遥前言：本框架实现的目的是在基于51单片机为控制芯片的产品内，因为51单片机的内存和堆栈比较有限，此框架比较简洁高效的。如果用于其他高性能的处理器内，可以考虑利用链表实现，实现更自由的操作。一、双层状态机...

关注、星标公众号，直达精彩内容

来源：小鱼儿飞丫飞

整理：技术让梦想更伟大 | 李肖遥

前言：

本框架实现的目的是在基于51单片机为控制芯片的产品内，因为51单片机的内存和堆栈比较有限，此框架比较简洁高效的。如果用于其他高性能的处理器内，可以考虑利用链表实现，实现更自由的操作。

一、双层状态机框架

状态机架构

调度器实现

该状态机有两个父类状态机（可自由添加更多父类状态机）

每个父类状态机内部有若干个子状态机（可自由添加更多子类状态机）

二、直接上代码

头文件如下：

/****************************************************************************
作者：小鱼儿飞丫飞
日期：2020-6-19
文件名：FSM层次状态机头文件
****************************************************************************/
#ifndef  __HSM_H__
#define  __HSM_H__

/****************************************************************************
头文件
****************************************************************************/
#include "stdio.h"
/****************************************************************************
红定义
****************************************************************************/
#define KEPP_STATE_CNT (5)
#define uint8_t  unsigned char
/****************************************************************************
变量
****************************************************************************/
typedef   void (*procedure) (void);//--函数指针
//--定义状态
typedef  enum  _FATHER_STATES{
s_father_init =0,
s_father_keep,
s_father_done,
s_father_default,
}E_father_states;
E_father_states  s_father_step;//--父类单个状态内部转换步骤
typedef  enum  _CHILDER_STATES{
s_childer_init =0,
s_childer_keep,
s_childer_done,
s_childer_default,
}E_childer_states;
E_childer_states  s_childer_step;//--子类单个状态内部转换步骤
//--定义状态成员函数
typedef  struct  __STATES_FUN{
procedure  steps[4] ;//--函数指针数组
}S_state_fun;

S_state_fun  father_state[2];//--超类集合
S_state_fun  childer_state[8];//--子类集合

typedef  enum {
e_static_state =0,
e_run_state ,
}E_hsm_father_state;
E_hsm_father_state  hsm_current_father_state;//--当前父状态
E_hsm_father_state  hsm_last_father_state;//-上一次父状态
typedef  enum {
e_set_state =0,
e_distribution_network_state ,
e_shut_down_state,
e_charge_state,
e_Normal_state,
e_dry_state,
e_besiege_state,
e_avoid_obstacles
}E_hsm_childer_state;
E_hsm_childer_state   hsm_current_childer_state;//--当前子状态
E_hsm_childer_state   hsm_last_childer_state;//--上一次子状态

/****************************************************************************
函数
****************************************************************************/
//--子状态是否允许跳转
uint8_t  Childer_State_Is_Allow_Jump(void);
//--子状态是否要发生状态转换
uint8_t  Is_Three_A_Childer_State_Transition(void);
//--子类状态转换
void  Childer_State_Transition(E_hsm_childer_state  temp);
//--子类更新上一次状态
void  Update_Childer_Last_State_Transition(void);
//--子类单个状态内部转换
void  Childer_Step_Transition(E_childer_states  temp);
//--父状态是否允许跳转
uint8_t  Father_State_Is_Allow_Jump(void);
//--父状态是否要发生状态转换
uint8_t  Is_Three_A_Father_State_Transition(void);
//--夫类状态转换
void  Father_State_Transition(E_hsm_father_state  temp);
//--父类更新上一次状态
void  Update_Father_Last_State_Transition(void);
//--夫类状态内部转换
void  Father_Step_Transition(E_father_states  temp);
/*************************************************
* 静止状态（夫类）
* 进入函数
* 保持函数
* 退出函数
* 错误函数
* *************************************************/
void  F_Static_Init(void );
void  F_Static_Keep(void);
void  F_Satic_Done(void );
void  F_Static_Default(void );
/*************************************************
* 运行状态（夫类）
* 进入函数
* 保持函数
* 退出函数
* 错误函数
* *************************************************/
void  F_Run_Init(void);
void  F_Run_Keep(void );
void  F_Run_Done(void );
void  F_Run_Default(void );
/*************************************************
* 设置状态（子类）依附静止（夫类）
* 进入函数
* 保持函数
* 退出函数
* 错误函数
* *************************************************/
void  C_Static_Set_Init();
void  C_Static_Set_Keep();
void  C_Satic_Set_Done();
void  C_Static_Set_Default();
/*************************************************
* 配网状态（子类）依附静止（夫类）
* 进入函数
* 保持函数
* 退出函数
* 错误函数
* *************************************************/
void  C_Static_Distribution_Network_Init(void );
void  C_Static_Distribution_Network_Keep(void );
void  C_Satic_Distribution_Network_Done(void );
void  C_Static_Distribution_Network_Default(void );
/*************************************************
* 待机状态（子类）依附静止（夫类）
* 进入函数
* 保持函数
* 退出函数
* 错误函数
* *************************************************/
void  C_Static_Shut_Down_Init(void );
void  C_Static_Shut_Down_Keep(void );
void  C_Satic_Shut_Down_Done(void );
void  C_Static_Shut_Down_Default(void );
/*************************************************
* 充电状态（子类）依附静止（夫类）
* 进入函数
* 保持函数
* 退出函数
* 错误函数
* *************************************************/
void  C_Static_Charge_Init(void );
void  C_Static_Charge_Keep(void );
void  C_Satic_Charge_Done(void );
void  C_Static_Charge_Default(void );

/*************************************************
* 正常状态（子类）依附运行（夫类）
* 进入函数
* 保持函数
* 退出函数
* 错误函数
* *************************************************/
void  C_Run_Normal_Init(void );
void  C_Run_Normal_Keep(void );
void  C_Run_Normal_Done(void );
void  C_Run_Normal_Default(void );
/*************************************************
* 干托状态（子类）依附运行（夫类）
* 进入函数
* 保持函数
* 退出函数
* 错误函数
* *************************************************/
void  C_Run_Dry_Init(void );
void  C_Run_Dry_Keep(void );
void  C_Run_Dry_Done(void );
void  C_Run_Dry_Default(void );
/*************************************************
* 受困状态（子类）依附运行（夫类）
* 进入函数
* 保持函数
* 退出函数
* 错误函数
* *************************************************/
void  C_Run_Besiege_Init(void );
void  C_Run_Besiege_Keep(void );
void  C_Run_Besiege_Done(void);
void  C_Run_Besiege_Default(void);
/*************************************************
* 避障状态（子类）依附运行（夫类）
* 进入函数
* 保持函数
* 退出函数
* 错误函数
* *************************************************/
void  C_Run_Avoid_Obstacles_Init(void );
void  C_Run_Avoid_Obstacles_Keep(void );
void  C_Run_Avoid_Obstacles_Done(void );
void  C_Run_Avoid_Obstacles_Default(void );

#endif
实现文件如下：

/****************************************************************************
作者：小鱼儿飞丫飞
日期：2020-6-19
文件名：FSM层次状态机执行文件
****************************************************************************/
/****************************************************************************
头文件
****************************************************************************/
#include  "hsm.h"
/****************************************************************************
红定义
****************************************************************************/

/****************************************************************************
变量
****************************************************************************/

S_state_fun father_state[2] ={
{F_Static_Init,F_Static_Keep,F_Satic_Done,F_Static_Default},
{F_Run_Init,F_Run_Keep,F_Run_Done,F_Run_Default }
};//--超类/夫类
S_state_fun childer_state[8]={
{ C_Static_Set_Init,C_Static_Set_Keep,C_Satic_Set_Done,C_Static_Set_Default},
{C_Static_Distribution_Network_Init,C_Static_Distribution_Network_Keep,C_Satic_Distribution_Network_Done,C_Static_Distribution_Network_Default},
{C_Static_Shut_Down_Init,C_Static_Shut_Down_Keep,C_Satic_Shut_Down_Done,C_Static_Shut_Down_Default},
{C_Static_Charge_Init,C_Static_Charge_Keep,C_Satic_Charge_Done,C_Static_Charge_Default},
{ C_Run_Normal_Init,C_Run_Normal_Keep,C_Run_Normal_Done,C_Run_Normal_Default},
{ C_Run_Dry_Init,C_Run_Dry_Keep, C_Run_Dry_Done,C_Run_Dry_Default},
{ C_Run_Besiege_Init,C_Run_Besiege_Keep,C_Run_Besiege_Done, C_Run_Besiege_Default},
{C_Run_Avoid_Obstacles_Init,C_Run_Avoid_Obstacles_Keep,C_Run_Avoid_Obstacles_Done,C_Run_Avoid_Obstacles_Default}
};//--子类1
E_father_states s_father_step=s_father_init ; //--父类单个状态内部转换步骤
E_childer_states s_childer_step = s_childer_init;
E_hsm_father_state hsm_current_father_state =  e_static_state;//--父类初始化
E_hsm_father_state hsm_last_father_state =  e_static_state ;
E_hsm_childer_state hsm_current_childer_state = e_set_state;//--子类初始化
E_hsm_childer_state hsm_last_childer_state = e_set_state;
/****************************************************************************
函数
状态函数命名规则
例： C_Static_Set_Init
C   ＿  Static_   Set  _    Init
Ｃ：子类Ｆ：父类＿依附的父类＿子类本身名字＿该子类状态内部阶段
****************************************************************************/
int  main(void)
{
int update_cnt = 10;
int run_cnt =1;
int cnt;
while(1)
{

if(update_cnt==80)
{
hsm_current_father_state =0;
hsm_current_childer_state = 0;
}
else if(update_cnt==70)
{
hsm_current_father_state =0;
hsm_current_childer_state = 1;
}
else if(update_cnt==60)
{
hsm_current_father_state =0;
hsm_current_childer_state = 2;
}
else if(update_cnt==50)
{
hsm_current_father_state =0;
hsm_current_childer_state = 3;
}
else if(update_cnt==40)
{
hsm_current_father_state =1;
hsm_current_childer_state = 4;
}
else if(update_cnt==30)
{
hsm_current_father_state =1;
hsm_current_childer_state = 5;
}
else if(update_cnt==20)
{
hsm_current_father_state =1;
hsm_current_childer_state = 6;
}
else if(update_cnt==10)
{
hsm_current_father_state =1;
hsm_current_childer_state = 7;
}
update_cnt--;
if(update_cnt==0)
{update_cnt =80;}
// printf("hsm_current_father_state:%d hsm_current_childer_state:%d\r\n",hsm_current_father_state,hsm_current_childer_state);
//=================================父类状态机调度器=========================================
if(Father_State_Is_Allow_Jump())//--如果允许跳转
father_state[hsm_current_father_state].steps[s_father_step]();//--父类状态
else
father_state[hsm_last_father_state].steps[s_father_step]();//--父类状态
//==========================================================================

}
return 0;
}
//--子状态是否允许跳转
uint8_t  Childer_State_Is_Allow_Jump(void)
{
if(s_childer_step == s_childer_init)
return 1;
else
return 0;
}
//--子状态是否要发生状态转换
uint8_t  Is_Three_A_Childer_State_Transition(void)
{
if(hsm_last_childer_state == hsm_current_childer_state)
return 0;
else
return 1;
}
//--子类状态转换
void  Childer_State_Transition(E_hsm_childer_state  temp)
{
hsm_current_childer_state = temp;
}
//--子类更新上一次状态
void  Update_Childer_Last_State_Transition(void)
{
hsm_last_childer_state = hsm_current_childer_state;
}
//--子类单个状态内部转换
void  Childer_Step_Transition(E_childer_states  temp)
{
s_childer_step = temp;
}
//--父状态是否允许跳转
uint8_t  Father_State_Is_Allow_Jump(void)
{
if(s_father_step == s_father_init)
return 1;
else
return 0;
}
//--父状态是否要发生状态转换
uint8_t  Is_Three_A_Father_State_Transition(void)
{
if(hsm_last_father_state == hsm_current_father_state)
return 0;
else
return 1;
}
//--夫类状态转换
void  Father_State_Transition(E_hsm_father_state  temp)
{
hsm_current_father_state = temp;
}
//--父类更新上一次状态
void  Update_Father_Last_State_Transition(void)
{
hsm_last_father_state = hsm_current_father_state;
}
//--夫类状态内部转换
void  Father_Step_Transition(E_father_states  temp)
{
s_father_step = temp;
}
/*************************************************
* 静止状态（夫类）
* 进入函数
* 保持函数
* 退出函数
* 错误函数
* *************************************************/
void  F_Static_Init(void)
{
Update_Father_Last_State_Transition();
//---------------------
//--代码段
printf("===父类：静止状态====进入函数>>>>>>>>>>>>>>>>>>>>>\r\n");
//--------------------
Father_Step_Transition(s_father_keep);
}
void  F_Static_Keep(void )
{
//---------------------
//--代码段
// printf("===父类：静止状态====保持函数--------------------\r\n");
//==========子类状态机调度器======================
if(Childer_State_Is_Allow_Jump())//--如果允许跳转
{
//--如果父类出现类跳转，子类已经做好跳转的准备，但是父类还未做好跳转的准备，此时不执行子类跳转
if(Is_Three_A_Father_State_Transition())
{
Father_Step_Transition(s_father_done);
return;
}
else
Father_Step_Transition(s_father_keep);
childer_state[hsm_current_childer_state].steps[s_childer_step]();//--子类状态
}
else
childer_state[hsm_last_childer_state].steps[s_childer_step]();//--子类状态
//--------------------

}
void  F_Satic_Done(void)
{
//---------------------
//--代码段
printf("===父类：静止状态====退出函数<<<<<<<<<<<<<<<<<<<<<<<<\r\n");
//--------------------
//--内部切换
Father_Step_Transition(s_father_init);
}
void  F_Static_Default(void )
{
;
}
/*************************************************
* 运行状态（夫类）
* 进入函数
* 保持函数
* 退出函数
* 错误函数
* *************************************************/
void  F_Run_Init(void )
{
Update_Father_Last_State_Transition();
//---------------------
//--代码段
printf("===父类：运行状态====进入函数>>>>>>>>>>>>>>>>>>>>>>>>>>\r\n");
//--------------------
Father_Step_Transition(s_father_keep);
}
void  F_Run_Keep(void )
{
//---------------------
//--代码段
//printf("===父类：运行状态====保持函数--------------------\r\n");
//==========子类状态机调度器======================
if(Childer_State_Is_Allow_Jump())//--如果允许跳转
{
//--如果父类出现类跳转，子类已经做好跳转的准备，但是父类还未做好跳转的准备，此时不执行子类跳转
if(Is_Three_A_Father_State_Transition())
{
Father_Step_Transition(s_father_done);
return;
}
else
Father_Step_Transition(s_father_keep);
childer_state[hsm_current_childer_state].steps[s_childer_step]();//--子类状态
}
else
childer_state[hsm_last_childer_state].steps[s_childer_step]();//--子类状态
}
void  F_Run_Done(void)
{
//---------------------
//--代码段
printf("===父类：运行状态====退出函数<<<<<<<<<<<<<<<<<<<<<<\r\n");
//--------------------
//--内部切换
Father_Step_Transition(s_father_init);
}
void  F_Run_Default(void )
{
;
}
/*************************************************
* 设置状态（子类）依附静止（夫类）
* 进入函数
* 保持函数
* 退出函数
* 错误函数
* *************************************************/
void  C_Static_Set_Init(void )
{
Update_Childer_Last_State_Transition();
//---------------------
//--代码段
printf("===子类：设置状态====进入函数>>>\r\n");
//--------------------
Childer_Step_Transition(s_childer_keep);
}
void  C_Static_Set_Keep(void )
{
//---------------------
//--代码段
printf("===子类：设置状态====保持函数\r\n");
//--------------------
if(Is_Three_A_Childer_State_Transition())
Childer_Step_Transition(s_childer_done);
else
Childer_Step_Transition(s_childer_keep);
}
void  C_Satic_Set_Done(void )
{
//---------------------
//--代码段
printf("===子类：设置状态====退出函数<<<\r\n");
//--------------------
//--内部切换
Childer_Step_Transition(s_childer_init);
}
void  C_Static_Set_Default(void)
{
;
}
/*************************************************
* 配网状态（子类）依附静止（夫类）
* 进入函数
* 保持函数
* 退出函数
* 错误函数
* *************************************************/
void  C_Static_Distribution_Network_Init(void )
{
Update_Childer_Last_State_Transition();
//---------------------
//--代码段
printf("===子类：陪网状态====进入函数>>>\r\n");
//--------------------
Childer_Step_Transition(s_childer_keep);
}
void  C_Static_Distribution_Network_Keep(void )
{
//---------------------
//--代码段
printf("===子类：陪网状态====保持函数\r\n");
//--------------------
if(Is_Three_A_Childer_State_Transition())
Childer_Step_Transition(s_childer_done);
else
Childer_Step_Transition(s_childer_keep);
}
void  C_Satic_Distribution_Network_Done(void )
{
//---------------------
//--代码段
printf("===子类：陪网状态====退出函数<<<\r\n");
//--------------------
//--内部切换
Childer_Step_Transition(s_childer_init);
}
void  C_Static_Distribution_Network_Default(void )
{
;
}
/*************************************************
* 待机状态（子类）依附静止（夫类）
* 进入函数
* 保持函数
* 退出函数
* 错误函数
* *************************************************/
void  C_Static_Shut_Down_Init(void )
{
Update_Childer_Last_State_Transition();
//---------------------
//--代码段
printf("===子类：待机状态====进入函数>>>\r\n");
//--------------------
Childer_Step_Transition(s_childer_keep);
}
void  C_Static_Shut_Down_Keep(void )
{
//---------------------
//--代码段
printf("===子类：待机状态====保持函数\r\n");
//--------------------
if(Is_Three_A_Childer_State_Transition())
Childer_Step_Transition(s_childer_done);
else
Childer_Step_Transition(s_childer_keep);
}
void  C_Satic_Shut_Down_Done(void )
{
//---------------------
//--代码段
printf("===子类：待机状态====退出函数<<<\r\n");
//--------------------
//--内部切换
Childer_Step_Transition(s_childer_init);
}
void  C_Static_Shut_Down_Default(void )
{
;
}

/*************************************************
* 充电状态（子类）依附静止（夫类）
* 进入函数
* 保持函数
* 退出函数
* 错误函数
* *************************************************/

void  C_Static_Charge_Init(void )
{
Update_Childer_Last_State_Transition();
//---------------------
//--代码段
printf("===子类：充电状态====进入函数>>>\r\n");
//--------------------
Childer_Step_Transition(s_childer_keep);
}
void  C_Static_Charge_Keep(void )
{
//---------------------
//--代码段
printf("===子类：充电状态====保持函数\r\n");
//--------------------
if(Is_Three_A_Childer_State_Transition())
Childer_Step_Transition(s_childer_done);
else
Childer_Step_Transition(s_childer_keep);
}
void  C_Satic_Charge_Done(void )
{
//---------------------
//--代码段
printf("===子类：充电状态====退出函数<<<\r\n");
//--------------------
//--内部切换
Childer_Step_Transition(s_childer_init);
}
void  C_Static_Charge_Default(void )
{
;
}

/*************************************************
* 正常状态（子类）依附运行（夫类）
* 进入函数
* 保持函数
* 退出函数
* 错误函数
* *************************************************/
void  C_Run_Normal_Init(void )
{
Update_Childer_Last_State_Transition();
//---------------------
//--代码段
printf("===子类：正常状态====进入函数>>>\r\n");
//--------------------
Childer_Step_Transition(s_childer_keep);
}
void  C_Run_Normal_Keep(void )
{
//---------------------
//--代码段
printf("===子类：正常状态====保持函数\r\n");
//--------------------
if(Is_Three_A_Childer_State_Transition())
Childer_Step_Transition(s_childer_done);
else
Childer_Step_Transition(s_childer_keep);
}
void  C_Run_Normal_Done(void)
{
//---------------------
//--代码段
printf("===子类：正常状态====退出函数<<<\r\n");
//--------------------
//--内部切换
Childer_Step_Transition(s_childer_init);
}
void  C_Run_Normal_Default(void)
{
;
}
/*************************************************
* 干托状态（子类）依附运行（夫类）
* 进入函数
* 保持函数
* 退出函数
* 错误函数
* *************************************************/
void  C_Run_Dry_Init(void )
{
Update_Childer_Last_State_Transition();
//---------------------
//--代码段
printf("===子类：干托状态====进入函数>>>\r\n");
//--------------------
Childer_Step_Transition(s_childer_keep);
}
void  C_Run_Dry_Keep(void )
{
//---------------------
//--代码段
printf("===子类：干托状态====保持函数\r\n");
//--------------------
if(Is_Three_A_Childer_State_Transition())
Childer_Step_Transition(s_childer_done);
else
Childer_Step_Transition(s_childer_keep);
}
void  C_Run_Dry_Done(void )
{
//---------------------
//--代码段
printf("===子类：干托状态====退出函数<<<\r\n");
//--------------------
//--内部切换
Childer_Step_Transition(s_childer_init);
}
void  C_Run_Dry_Default(void )
{
;
}
/*************************************************
* 受困状态（子类）依附运行（夫类）
* 进入函数
* 保持函数
* 退出函数
* 错误函数
* *************************************************/
void  C_Run_Besiege_Init(void )
{
Update_Childer_Last_State_Transition();
//---------------------
//--代码段
printf("===子类：受困状态====进入函数>>>\r\n");
//--------------------
Childer_Step_Transition(s_childer_keep);
}
void  C_Run_Besiege_Keep(void )
{
//---------------------
//--代码段
printf("===子类：受困状态====保持函数\r\n");
//--------------------
if(Is_Three_A_Childer_State_Transition())
Childer_Step_Transition(s_childer_done);
else
Childer_Step_Transition(s_childer_keep);
}
void  C_Run_Besiege_Done(void )
{
//---------------------
//--代码段
printf("===子类：受困状态====退出函数<<<\r\n");
//--------------------
//--内部切换
Childer_Step_Transition(s_childer_init);
}
void  C_Run_Besiege_Default(void )
{
;
}
/*************************************************
* 避障状态（子类）依附运行（夫类）
* 进入函数
* 保持函数
* 退出函数
* 错误函数
* *************************************************/
void  C_Run_Avoid_Obstacles_Init(void )
{
Update_Childer_Last_State_Transition();
//---------------------
//--代码段
printf("===子类：避障状态====进入函数>>>\r\n");
//--------------------
Childer_Step_Transition(s_childer_keep);
}
void  C_Run_Avoid_Obstacles_Keep(void )
{
//---------------------
//--代码段
printf("===子类：避障状态====保持函数\r\n");
//--------------------
if(Is_Three_A_Childer_State_Transition())
Childer_Step_Transition(s_childer_done);
else
Childer_Step_Transition(s_childer_keep);
}
void  C_Run_Avoid_Obstacles_Done(void )
{
//---------------------
//--代码段
printf("===子类：避障状态====退出函数<<<\r\n");
//--------------------
//--内部切换
Childer_Step_Transition(s_childer_init);
}
void  C_Run_Avoid_Obstacles_Default(void )
{
;
}