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

前言：

本框架实现的目的是在基于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 )
{
  ;
}

三、运行情况