C语言中的状态机设计深入讲解

 前言

本文不是关于软件状态机的最佳设计分解实践的教程。我将重点关注状态机代码和简单的示例，这些示例具有足够的复杂性，以便于理解特性和用法。

吴桥ssl适用于网站、小程序/APP、API接口等需要进行数据传输应用场景，ssl证书未来市场广阔！成为成都创新互联公司的ssl证书销售渠道，可以享受市场价格4-6折优惠！如果有意向欢迎电话联系或者加微信：13518219792（备注：SSL证书合作）期待与您的合作！

背景

大多数程序员常用的设计技术是有限状态机(FSM)。设计人员使用此编程结构将复杂的问题分解为可管理的状态和状态转换。有无数种实现状态机的方法。

A switch语句提供了状态机最容易实现和最常见的版本之一。在这里，每个案例在switch语句成为一个状态，实现如下所示：

 
 
 
 
    
  
  
  
  
  1. switch (currentState) {  
    2.   
  
  
  
  2.  case ST_IDLE:  
    3.   
  
  
  
  3.  // do something in the idle state  
    4.   
  
  
  
  4.  break;   
    5.   
  
  
  
  5.  case ST_STOP:  
    6.   
  
  
  
  6.  // do something in the stop state  
    7.   
  
  
  
  7.  break;  
    8.   
  
  
  
  8.  // etc...  
    9.   
  
  
  
  9. } 
    10.

这种方法当然适合于解决许多不同的设计问题。然而，在事件驱动的多线程项目上使用时，这种形式的状态机可能是非常有限的。

第一个问题是控制哪些状态转换是有效的，哪些是无效的。无法强制执行状态转换规则。任何过渡都可以在任何时候进行，这并不是特别可取的。对于大多数设计，只有少数转换模式是有效的。理想情况下，软件设计应该强制执行这些预定义的状态序列，并防止不必要的转换。当试图将数据发送到特定状态时，会出现另一个问题。由于整个状态机位于单个函数中，因此向任何给定状态发送额外数据都是困难的。最后，这些设计很少适合在多线程系统中使用。设计器必须确保状态机是从单个控制线程调用的。

为什么要用国家机器？

使用状态机实现代码是解决复杂工程问题的一种非常方便的设计技术。状态机将设计分解为一系列步骤，或在状态机术语中称为状态。每个状态都执行一些狭义的任务。另一方面，事件是一种刺激，它导致状态机在状态之间移动或过渡。

举一个简单的例子，我将在本文中使用它，假设我们正在设计电机控制软件。我们想启动和停止电机，以及改变电机的速度。很简单。向客户端软件公开的电机控制事件如下：

  •  设定速度-设定电机以特定速度行驶
  •  站住-停止马达

这些事件提供了以任何速度启动电机的能力，这也意味着改变已经移动的电机的速度。或者我们可以完全停止马达。对于电机控制模块，这两个事件或功能被认为是外部事件.然而，对于使用我们的代码的客户机来说，这些只是普通的函数。

这些事件不是状态机状态。处理这两个事件所需的步骤是不同的。在这种情况下，各州是：

  •  闲散-马达不是旋转的，而是静止的
  •  无所事事
  •  启动-从死胡同启动马达
  •  开启电动机电源
  •  设定电机转速
  •  变速-调整已经移动的马达的速度
  •  改变电机转速
  •  停-停止移动的马达
  •  关闭电动机电源
  •  进入闲置状态

可以看出，将电机控制分解为离散状态，而不是单一的功能，我们可以更容易地管理如何操作电机的规则。

每个状态机都有“当前状态”的概念。这是状态机当前所处的状态。在任何给定的时刻，状态机只能处于单一状态。特定状态机实例的每个实例在定义时都可以设置初始状态。但是，该初始状态在对象创建期间不执行。只有发送到状态机的事件才会导致执行状态函数。

为了图形化地说明状态和事件，我们使用状态图。下面的图1显示了电机控制模块的状态转换。框表示状态，连接箭头表示事件转换。列出事件名称的箭头是外部事件，而未装饰的行被认为是内部事件。(本文后面将介绍内部事件和外部事件之间的差异。)

图1：电机状态图

如您所见，当事件在状态转换中出现时，所发生的状态转换取决于状态机的当前状态。当SetSpeed事件出现，例如，电机在Idle状态，则转换为Start状态。然而，同样的SetSpeed当前状态为Start将电机转换为ChangeSpeed状态。您还可以看到，并非所有的状态转换都是有效的。例如，马达不能从ChangeSpeed到Idle而不需要先通过Stop状态。

简而言之，使用状态机捕获和执行复杂的交互，否则可能很难传递和实现。

内外事件

正如我前面提到的，事件是导致状态机在状态之间转换的刺激。例如，按下按钮可能是一个事件。事件可以分为两类：外部事件和内部事件。外部事件，在其最基本的级别上，是对状态机模块的函数调用.这些函数是公共的，从外部调用，或者从外部代码调用到状态机对象。系统中的任何线程或任务都可以生成外部事件。如果外部事件函数调用导致状态转换发生，则状态将在调用方的控制线程内同步执行。另一方面，内部事件是由状态机本身在状态执行期间自行生成的。

典型的场景由生成的外部事件组成，该事件同样可以归结为模块的公共接口中的函数调用。根据正在生成的事件和状态机的当前状态，执行查找以确定是否需要转换。如果是这样，状态机将转换到新状态，并执行该状态的代码。在状态函数的末尾，执行检查以确定是否生成了内部事件。如果是这样，则执行另一个转换，并且新的状态有机会执行。此过程将继续进行，直到状态机不再生成内部事件，此时原始外部事件函数调用将返回。外部事件和所有内部事件(如果有的话)在调用者的控制线程中执行。

一旦外部事件启动状态机执行，它不能被另一个外部事件中断，直到外部事件和所有内部事件已经完成执行，如果使用锁。这个运行到完成模型为状态转换提供了一个多线程安全的环境。可以在状态机引擎中使用信号量或互斥量来阻止可能同时访问同一状态机实例的其他线程。见源代码函数_SM_ExternalEvent()关于锁的位置的注释。

事件数据

生成事件时，它可以选择附加事件数据，以便在执行过程中由状态函数使用。事件数据是一个const或者不是-const 指向任何内置或用户定义的数据类型的指针。

一旦状态完成执行，事件数据就被认为用完了，必须删除。因此，发送到状态机的任何事件数据都必须通过SM_XAlloc()。状态机引擎自动释放分配的事件数据。SM_XFree().

状态转变

当生成外部事件时，执行查找以确定状态转换操作过程。事件有三种可能的结果：新状态、忽略事件或不能发生。新状态会导致转换到允许执行的新状态。转换到现有状态也是可能的，这意味着当前状态被重新执行。对于被忽略的事件，不执行任何状态。但是，事件数据(如果有的话)将被删除。最后一种不可能发生的可能性是保留在事件在状态机的当前状态下无效的情况下使用的。如果发生这种情况，软件就会出现故障。

在此实现中，执行验证转换查找不需要内部事件。假设状态转换是有效的。您可以检查有效的内部和外部事件转换，但实际上，这只会占用更多的存储空间，并且只会产生很少的好处。验证转换的真正需要在于异步的外部事件，在这些事件中，客户端可能导致事件在不适当的时间发生。一旦状态机执行，它就不能被中断。它处于私有实现的控制之下，因此没有必要进行转换检查。这使设计人员可以自由地通过内部事件更改状态，而无需更新转换表。

状态机模块

状态机源代码包含在_StateMachine.c_和_StateMachine.h_档案。下面的代码显示了部分标题。这个StateMachine 报头包含各种预处理器多行宏，以简化状态机的实现。

 
 
 
 
    
  
  
  
  
  1. enum { EVENT_IGNORED = 0xFE, CANNOT_HAPPEN = 0xFF };   
    2.   
  
  
  
  2. typedef void NoEventData;   
    3.   
  
  
  
  3. // State machine constant data  
    4.   
  
  
  
  4. typedef struct  
    5.   
  
  
  
  5. {  
    6.   
  
  
  
  6.  const CHAR* name;  
    7.   
  
  
  
  7.  const BYTE maxStates;  
    8.   
  
  
  
  8.  const struct SM_StateStruct* stateMap;  
    9.   
  
  
  
  9.  const struct SM_StateStructEx* stateMapEx; 
    10.   
  
  
  
  10. } SM_StateMachineConst;  
    11.   
  
  
  
  11. // State machine instance data  
    12.   
  
  
  
  12. typedef struct  
    13.   
  
  
  
  13. {  
    14.   
  
  
  
  14.  const CHAR* name;  
    15.   
  
  
  
  15.  void* pInstance;  
    16.   
  
  
  
  16.  BYTE newState;  
    17.   
  
  
  
  17.  BYTE currentState;  
    18.   
  
  
  
  18.  BOOL eventGenerated;  
    19.   
  
  
  
  19.  void* pEventData;  
    20.   
  
  
  
  20. } SM_StateMachine;   
    21.   
  
  
  
  21. // Generic state function signatures  
    22.   
  
  
  
  22. typedef void (*SM_StateFunc)(SM_StateMachine* self, void* pEventData);  
    23.   
  
  
  
  23. typedef BOOL (*SM_GuardFunc)(SM_StateMachine* self, void* pEventData);  
    24.   
  
  
  
  24. typedef void (*SM_EntryFunc)(SM_StateMachine* self, void* pEventData);  
    25.   
  
  
  
  25. typedef void (*SM_ExitFunc)(SM_StateMachine* self);  
    26.   
  
  
  
  26. typedef struct SM_StateStruct  
    27.   
  
  
  
  27. {  
    28.   
  
  
  
  28.  SM_StateFunc pStateFunc;  
    29.   
  
  
  
  29. } SM_StateStruct;   
    30.   
  
  
  
  30. typedef struct SM_StateStructEx  
    31.   
  
  
  
  31. {  
    32.   
  
  
  
  32.  SM_StateFunc pStateFunc;  
    33.   
  
  
  
  33.  SM_GuardFunc pGuardFunc;  
    34.   
  
  
  
  34.  SM_EntryFunc pEntryFunc;  
    35.   
  
  
  
  35.  SM_ExitFunc pExitFunc;  
    36.   
  
  
  
  36. } SM_StateStructEx;  
    37.   
  
  
  
  37. // Public functions  
    38.   
  
  
  
  38. #define SM_Event(_smName_, _eventFunc_, _eventData_)   
    39.   
  
  
  
  39.  _eventFunc_(&_smName_##Obj, _eventData_)  
    40.   
  
  
  
  40. // Protected functions  
    41.   
  
  
  
  41. #define SM_InternalEvent(_newState_, _eventData_)   
    42.   
  
  
  
  42.  _SM_InternalEvent(self, _newState_, _eventData_)  
    43.   
  
  
  
  43. #define SM_GetInstance(_instance_)   
    44.   
  
  
  
  44.  (_instance_*)(self->pInstance);  
    45.   
  
  
  
  45. // Private functions  
    46.   
  
  
  
  46. void _SM_ExternalEvent(SM_StateMachine* self,   
    47.   
  
  
  
  47.  const SM_StateMachineConst* selfConst, BYTE newState, void* pEventData);  
    48.   
  
  
  
  48. void _SM_InternalEvent(SM_StateMachine* self, BYTE newState, void* pEventData);  
    49.   
  
  
  
  49. void _SM_StateEngine(SM_StateMachine* self, const SM_StateMachineConst* selfConst);  
    50.   
  
  
  
  50. void _SM_StateEngineEx(SM_StateMachine* self, const SM_StateMachineConst* selfConst);  
    51.   
  
  
  
  51. #define SM_DECLARE(_smName_)   
    52.   
  
  
  
  52.  extern SM_StateMachine _smName_##Obj;   
    53.   
  
  
  
  53. #define SM_DEFINE(_smName_, _instance_)   
    54.   
  
  
  
  54.  SM_StateMachine _smName_##Obj = { #_smName_, _instance_,   
    55.   
  
  
  
  55.  0, 0, 0, 0 };   
    56.   
  
  
  
  56. #define EVENT_DECLARE(_eventFunc_, _eventData_)   
    57.   
  
  
  
  57.  void _eventFunc_(SM_StateMachine* self, _eventData_* pEventData);  
    58.   
  
  
  
  58. #define EVENT_DEFINE(_eventFunc_, _eventData_)   
    59.   
  
  
  
  59.  void _eventFunc_(SM_StateMachine* self, _eventData_* pEventData)  
    60.   
  
  
  
  60. #define STATE_DECLARE(_stateFunc_, _eventData_)   
    61.   
  
  
  
  61.  static void ST_##_stateFunc_(SM_StateMachine* self, _eventData_* pEventData);  
    62.   
  
  
  
  62. #define STATE_DEFINE(_stateFunc_, _eventData_)   
    63.   
  
  
  
  63.  static void ST_##_stateFunc_(SM_StateMachine* self, _eventData_* pEventData) 
    64.

这个SM_Event()宏用于生成外部事件，而SM_InternalEvent()在执行状态函数期间生成内部事件。SM_GetInstance()获取指向当前状态机对象的指针。

SM_DECLARE 和SM_DEFINE用于创建状态机实例。EVENT_DECLARE和EVENT_DEFINE创建外部事件函数。最后，STATE_DECLARE和STATE_DEFINE创建状态函数。

电机实例

Motor 实现我们假设的电机控制状态机，其中客户端可以启动电机，以特定的速度，并停止电机。这个Motor标题接口如下所示：

 
 
 
 
    
  
  
  
  
  1. #include "StateMachine.h"   
    2.   
  
  
  
  2. // Motor object structure  
    3.   
  
  
  
  3. typedef struct  
    4.   
  
  
  
  4. {  
    5.   
  
  
  
  5.  INT currentSpeed;  
    6.   
  
  
  
  6. } Motor;   
    7.   
  
  
  
  7. // Event data structure  
    8.   
  
  
  
  8. typedef struct  
    9.   
  
  
  
  9. {  
    10.   
  
  
  
  10.  INT speed;  
    11.   
  
  
  
  11. } MotorData;  
    12.   
  
  
  
  12. // State machine event functions  
    13.   
  
  
  
  13. EVENT_DECLARE(MTR_SetSpeed, MotorData)  
    14.   
  
  
  
  14. EVENT_DECLARE(MTR_Halt, NoEventData) 
    15.

这个Motor源文件使用宏通过隐藏所需的状态机机器来简化使用。

 
 
 
 
    
  
  
  
  
  1. // State enumeration order must match the order of state  
    2.   
  
  
  
  2. // method entries in the state map  
    3.   
  
  
  
  3. enum States  
    4.   
  
  
  
  4. {  
    5.   
  
  
  
  5.  ST_IDLE,  
    6.   
  
  
  
  6.  ST_STOP,  
    7.   
  
  
  
  7.  ST_START,  
    8.   
  
  
  
  8.  ST_CHANGE_SPEED,  
    9.   
  
  
  
  9.  ST_MAX_STATES  
    10.   
  
  
  
  10. };  
    11.   
  
  
  
  11. // State machine state functions  
    12.   
  
  
  
  12. STATE_DECLARE(Idle, NoEventData)  
    13.   
  
  
  
  13. STATE_DECLARE(Stop, NoEventData)  
    14.   
  
  
  
  14. STATE_DECLARE(Start, MotorData)  
    15.   
  
  
  
  15. STATE_DECLARE(ChangeSpeed, MotorData)  
    16.   
  
  
  
  16. // State map to define state function order  
    17.   
  
  
  
  17. BEGIN_STATE_MAP(Motor)  
    18.   
  
  
  
  18.  STATE_MAP_ENTRY(ST_Idle)  
    19.   
  
  
  
  19.  STATE_MAP_ENTRY(ST_Stop)  
    20.   
  
  
  
  20.  STATE_MAP_ENTRY(ST_Start)  
    21.   
  
  
  
  21.  STATE_MAP_ENTRY(ST_ChangeSpeed)  
    22.   
  
  
  
  22. END_STATE_MAP(Motor)   
    23.   
  
  
  
  23. // Set motor speed external event  
    24.   
  
  
  
  24. EVENT_DEFINE(MTR_SetSpeed, MotorData)  
    25.   
  
  
  
  25. {  
    26.   
  
  
  
  26.  // Given the SetSpeed event, transition to a new state based upon   
    27.   
  
  
  
  27.  // the current state of the state machine  
    28.   
  
  
  
  28.  BEGIN_TRANSITION_MAP  // - Current State -  
    29.   
  
  
  
  29.  TRANSITION_MAP_ENTRY(ST_START) // ST_Idle   
    30.   
  
  
  
  30.  TRANSITION_MAP_ENTRY(CANNOT_HAPPEN) // ST_Stop   
    31.   
  
  
  
  31.  TRANSITION_MAP_ENTRY(ST_CHANGE_SPEED) // ST_Start   
    32.   
  
  
  
  32.  TRANSITION_MAP_ENTRY(ST_CHANGE_SPEED) // ST_ChangeSpeed  
    33.   
  
  
  
  33.  END_TRANSITION_MAP(Motor, pEventData)  
    34.   
  
  
  
  34. }  
    35.   
  
  
  
  35. // Halt motor external event  
    36.   
  
  
  
  36. EVENT_DEFINE(MTR_Halt, NoEventData)  
    37.   
  
  
  
  37. {  
    38.   
  
  
  
  38.  // Given the Halt event, transition to a new state based upon   
    39.   
  
  
  
  39.  // the current state of the state machine  
    40.   
  
  
  
  40.  BEGIN_TRANSITION_MAP  // - Current State -  
    41.   
  
  
  
  41.  TRANSITION_MAP_ENTRY(EVENT_IGNORED) // ST_Idle  
    42.   
  
  
  
  42.  TRANSITION_MAP_ENTRY(CANNOT_HAPPEN) // ST_Stop 
    43.   
  
  
  
  43.  TRANSITION_MAP_ENTRY(ST_STOP) // ST_Start  
    44.   
  
  
  
  44.  TRANSITION_MAP_ENTRY(ST_STOP) // ST_ChangeSpeed  
    45.   
  
  
  
  45.  END_TRANSITION_MAP(Motor, pEventData) 
    46.   
  
  
  
  46.  } 
    47.

外部事件

MTR_SetSpeed 和MTR_Halt类中的外部事件。Motor状态机。MTR_SetSpeed 获取指向MotorData事件数据，包含电机速度。此数据结构将使用SM_XFree()在状态处理完成后，必须使用SM_XAlloc()函数调用之前。

州数

每个状态函数都必须有一个与其关联的枚举。这些枚举用于存储状态机的当前状态。在……里面Motor, States提供这些枚举，这些枚举稍后用于对转换映射和状态映射查找表进行索引。

状态函数

状态函数实现每个状态--每个状态机状态一个状态函数。STATE_DECLARE 用于声明状态函数接口和STATE_DEFINE 定义实现。

 
 
 
 
    
  
  
  
  
  1. // State machine sits here when motor is not running  
    2.   
  
  
  
  2. STATE_DEFINE(Idle, NoEventData)  
    3.   
  
  
  
  3. {  
    4.   
  
  
  
  4.  printf("%s ST_Idlen", self->name);  
    5.   
  
  
  
  5. }   
    6.   
  
  
  
  6. // Stop the motor   
    7.   
  
  
  
  7. STATE_DEFINE(Stop, NoEventData)  
    8.   
  
  
  
  8. {  
    9.   
  
  
  
  9.  // Get pointer to the instance data and update currentSpeed  
    10.   
  
  
  
  10.  Motor* pInstance = SM_GetInstance(Motor);  
    11.   
  
  
  
  11.  pInstance->currentSpeed = 0;   
    12.   
  
  
  
  12.  // Perform the stop motor processing here  
    13.   
  
  
  
  13.  printf("%s ST_Stop: %dn", self->name, pInstance->currentSpeed);  
    14.   
  
  
  
  14.  // Transition to ST_Idle via an internal event  
    15.   
  
  
  
  15.  SM_InternalEvent(ST_IDLE, NULL);  
    16.   
  
  
  
  16. }  
    17.   
  
  
  
  17. // Start the motor going  
    18.   
  
  
  
  18. STATE_DEFINE(Start, MotorData) 
    19.   
  
  
  
  19. {  
    20.   
  
  
  
  20.  ASSERT_TRUE(pEventData);  
    21.   
  
  
  
  21.  // Get pointer to the instance data and update currentSpeed  
    22.   
  
  
  
  22.  Motor* pInstance = SM_GetInstance(Motor);  
    23.   
  
  
  
  23.  pInstance->currentSpeed = pEventData->speed;   
    24.   
  
  
  
  24.  // Set initial motor speed processing here  
    25.   
  
  
  
  25.  printf("%s ST_Start: %dn", self->name, pInstance->currentSpeed);  
    26.   
  
  
  
  26. }  
    27.   
  
  
  
  27. // Changes the motor speed once the motor is moving  
    28.   
  
  
  
  28. STATE_DEFINE(ChangeSpeed, MotorData)  
    29.   
  
  
  
  29. {  
    30.   
  
  
  
  30.  ASSERT_TRUE(pEventData);  
    31.   
  
  
  
  31.  // Get pointer to the instance data and update currentSpeed  
    32.   
  
  
  
  32.  Motor* pInstance = SM_GetInstance(Motor);  
    33.   
  
  
  
  33.  pInstance->currentSpeed = pEventData->speed;  
    34.   
  
  
  
  34.  // Perform the change motor speed here  
    35.   
  
  
  
  35.  printf("%s ST_ChangeSpeed: %dn", self->name, pInstance->currentSpeed);  
    36.   
  
  
  
  36. } 
    37.

STATE_DECLARE和STATE_DEFINE用两个参数。第一个参数是状态函数名。第二个参数是事件数据类型。如果不需要事件数据，请使用NoEventData。宏也可用于创建保护、退出和入口操作，本文稍后将对这些操作进行解释。

这个SM_GetInstance()宏获取状态机对象的实例。宏的参数是状态机名。

在此实现中，所有状态机函数都必须遵守这些签名，如下所示：

 
 
 
 
    
  
  
  
  
  1. // Generic state function signatures  
    2.   
  
  
  
  2. typedef void (*SM_StateFunc)(SM_StateMachine* self, void* pEventData);  
    3.   
  
  
  
  3. typedef BOOL (*SM_GuardFunc)(SM_StateMachine* self, void* pEventData);  
    4.   
  
  
  
  4. typedef void (*SM_EntryFunc)(SM_StateMachine* self, void* pEventData);  
    5.   
  
  
  
  5. typedef void (*SM_ExitFunc)(SM_StateMachine* self);  
    6.

各SM_StateFunc 接受指向SM_StateMachine对象和事件数据。如果NoEventData 被使用时，pEventData争论将是NULL。否则，pEventData参数的类型为STATE_DEFINE.

在……里面Motor氏Start状态函数STATE_DEFINE(Start, MotorData) 宏扩展到：

 
 
 
 
    
  
  
  
  
  1. void ST_Start(SM_StateMachine* self, MotorData* pEventData) 
    2.

注意，每个状态函数都有self 和pEventData 争论。self 是指向状态机对象的指针，并且pEventData 事件数据。还请注意，宏以“ST_“用于创建函数的状态名称。ST_Start().

类似地，Stop 状态函数STATE_DEFINE(Stop, NoEventData)IS扩展到：

 
 
 
 
    
  
  
  
  
  1. void ST_Stop(SM_StateMachine* self, void* pEventData) 
    2.

Stop 不接受事件数据，因此pEventData 论点是void*.

每个状态/保护/入口/退出函数在宏中自动添加三个字符。例如，如果使用STATE_DEFINE(Idle, NoEventData)实际的状态函数名被调用。ST_Idle().

  •  ST_-状态函数前置字符
  •  GD_-保护功能前置字符
  •  EN_-入口函数前面的字符
  •  EX_-退出函数前置字符

SM_GuardFunc 和SM_Entry 功能typedef也接受事件数据。SM_ExitFunc 是唯一的，因为不允许任何事件数据。

状态图

状态机引擎通过使用状态映射知道要调用哪个状态函数.状态图映射currentState变量设置为特定的状态函数。例如，如果currentState 是2，则调用第三个状态映射函数指针项(从零计数)。状态映射表是使用以下三个宏创建的：

 
 
 
 
    
  
  
  
  
  1. BEGIN_STATE_MAP  
    2.   
  
  
  
  2. STATE_MAP_ENTRY  
    3.   
  
  
  
  3. END_STATE_MAP 
    4.

BEGIN_STATE_MAP 启动状态映射序列。各STATE_MAP_ENTRY 有一个状态函数名称参数。END_STATE_MAP终止地图。国家地图Motor 如下所示：

 
 
 
 
    
  
  
  
  
  1. BEGIN_STATE_MAP(Motor)  
    2.   
  
  
  
  2.  STATE_MAP_ENTRY(ST_Idle) 
    3.   
  
  
  
  3.  STATE_MAP_ENTRY(ST_Stop)  
    4.   
  
  
  
  4.  STATE_MAP_ENTRY(ST_Start)  
    5.   
  
  
  
  5.  STATE_MAP_ENTRY(ST_ChangeSpeed)  
    6.   
  
  
  
  6. END_STATE_MAP 
    7.

或者，警卫/入口/出口特性需要利用_EX(扩展)宏的版本。

 
 
 
 
    
  
  
  
  
  1. BEGIN_STATE_MAP_EX  
    2.   
  
  
  
  2. STATE_MAP_ENTRY_EX or STATE_MAP_ENTRY_ALL_EX   
    3.   
  
  
  
  3. END_STATE_MAP_EX 
    4.

这个STATE_MAP_ENTRY_ALL_EX 宏按照该顺序为状态操作、保护条件、入口操作和退出操作设置了四个参数。状态操作是强制性的，但其他操作是可选的。如果状态没有动作，则使用0为了争论。如果状态没有任何保护/进入/退出选项，则STATE_MAP_ENTRY_EX 宏将所有未使用的选项默认为0。下面的宏片段是本文后面介绍的一个高级示例。

 
 
 
 
    
  
  
  
  
  1. // State map to define state function order  
    2.   
  
  
  
  2. BEGIN_STATE_MAP_EX(CentrifugeTest)  
    3.   
  
  
  
  3.  STATE_MAP_ENTRY_ALL_EX(ST_Idle, 0, EN_Idle, 0)  
    4.   
  
  
  
  4.  STATE_MAP_ENTRY_EX(ST_Completed)  
    5.   
  
  
  
  5.  STATE_MAP_ENTRY_EX(ST_Failed)  
    6.   
  
  
  
  6.  STATE_MAP_ENTRY_ALL_EX(ST_StartTest, GD_StartTest, 0, 0)  
    7.   
  
  
  
  7.  STATE_MAP_ENTRY_EX(ST_Acceleration)  
    8.   
  
  
  
  8.  STATE_MAP_ENTRY_ALL_EX(ST_WaitForAcceleration, 0, 0, EX_WaitForAcceleration)  
    9.   
  
  
  
  9.  STATE_MAP_ENTRY_EX(ST_Deceleration)  
    10.   
  
  
  
  10.  STATE_MAP_ENTRY_ALL_EX(ST_WaitForDeceleration, 0, 0, EX_WaitForDeceleration)  
    11.   
  
  
  
  11. END_STATE_MAP_EX(CentrifugeTest) 
    12.

不要忘记添加前面的字符(ST_, GD_, EN_或EX_)每项功能。

状态机对象

在C++中，对象是语言的组成部分。使用C，您必须更加努力地完成类似的行为。此C语言状态机支持多个状态机对象(或多个实例)，而不是具有单个静态状态机实现。

这个SM_StateMachine 数据结构存储状态机实例数据；每个状态机实例存储一个对象。这个SM_StateMachineConst 数据结构存储常量数据；每个状态机类型都有一个常量对象。

状态机使用SM_DEFINE 宏。第一个参数是状态机名称。第二个参数是指向用户定义的状态机结构的指针，或NULL 如果没有用户对象。

 
 
 
 
    
  
  
  
  
  1. #define SM_DEFINE(_smName_, _instance_)   
    2.   
  
  
  
  2.  SM_StateMachine _smName_##Obj = { #_smName_, _instance_,   
    3.   
  
  
  
  3.  0, 0, 0, 0 }; 
    4.

在本例中，状态机名称为Motor创建了两个对象和两个状态机。

 
 
 
 
    
  
  
  
  
  1. // Define motor objects  
    2.   
  
  
  
  2. static Motor motorObj1;  
    3.   
  
  
  
  3. static Motor motorObj2;   
    4.   
  
  
  
  4. // Define two public Motor state machine instances  
    5.   
  
  
  
  5. SM_DEFINE(Motor1SM, &motorObj1)  
    6.   
  
  
  
  6. SM_DEFINE(Motor2SM, &motorObj2) 
    7.

每个马达对象独立地处理状态执行。这个Motor 结构用于存储状态机特定于实例的数据。在状态函数中，使用SM_GetInstance()获取指向Motor 对象在运行时初始化。

 
 
 
 
    
  
  
  
  
  1. // Get pointer to the instance data and update currentSpeed  
    2.   
  
  
  
  2. Motor* pInstance = SM_GetInstance(Motor); 
    3.   
  
  
  
  3. pInstance->currentSpeed = pEventData->speed; 
    4.

过渡图

要注意的最后一个细节是状态转换规则。状态机如何知道应该发生什么转换？答案是过渡图。转换映射是映射currentState 变量为状态枚举常量。每个外部事件函数都有一个用三个宏创建的转换映射表：

 
 
 
 
    
  
  
  
  
  1. BEGIN_TRANSITION_MAP  
    2.   
  
  
  
  2. TRANSITION_MAP_ENTRY  
    3.   
  
  
  
  3. END_TRANSITION_MAP 
    4.

这个MTR_Halt 事件函数Motor 将转换映射定义为：

 
 
 
 
    
  
  
  
  
  1. // Halt motor external event  
    2.   
  
  
  
  2. EVENT_DEFINE(MTR_Halt, NoEventData)  
    3.   
  
  
  
  3. {  
    4.   
  
  
  
  4.  // Given the Halt event, transition to a new state based upon   
    5.   
  
  
  
  5.  // the current state of the state machine  
    6.   
  
  
  
  6.  BEGIN_TRANSITION_MAP   // - Current State -  
    7.   
  
  
  
  7.  TRANSITION_MAP_ENTRY(EVENT_IGNORED) // ST_Idle  
    8.   
  
  
  
  8.  TRANSITION_MAP_ENTRY(CANNOT_HAPPEN) // ST_Stop  
    9.   
  
  
  
  9.  TRANSITION_MAP_ENTRY(ST_STOP)  // ST_Start  
    10.   
  
  
  
  10.  TRANSITION_MAP_ENTRY(ST_STOP)  // ST_ChangeSpeed  
    11.   
  
  
  
  11.  END_TRANSITION_MAP(Motor, pEventData)  
    12.   
  
  
  
  12. } 
    13.

BEGIN_TRANSITION_MAP开始地图。各TRANSITION_MAP_ENTRY它指示状态机根据当前状态应该做什么。每个转换映射表中的条目数必须与状态函数的数目完全匹配。在我们的例子中，我们有四个状态函数，所以我们需要四个转换映射条目。每个条目的位置与州映射中定义的状态函数的顺序相匹配。因此，第一个条目在MTR_Halt函数表示EVENT_IGNORED 如下所示：

 
 
 
 
    
  
  
  
  
  1. TRANSITION_MAP_ENTRY (EVENT_IGNORED) // ST_Idle 
    2.

这被解释为“如果在当前状态为状态空闲时发生了暂停事件，只需忽略该事件”。

同样，地图上的第三个条目是：

 
 
 
 
    
  
  
  
  
  1. TRANSITION_MAP_ENTRY (ST_STOP) // ST_Start 
    2.

这表示“如果在当前为状态启动时发生了暂停事件，则转换为状态停止”。

END_TRANSITION_MAP 终止地图。此宏的第一个参数是状态机名称。第二个参数是事件数据。

这个C_ASSERT()宏在END_TRANSITION_MAP。如果状态机状态数与转换映射项的数目不匹配，则生成编译时错误。

新的状态机步骤

创建一个新的状态机需要一些基本的高级步骤：

  •  创建一个States 每个状态函数有一个条目的枚举
  •  定义状态函数
  •  定义事件函数
  •  创建一个状态映射查找表。STATE_MAP宏
  •  为每个外部事件函数创建一个转换映射查找表。TRANSITION_MAP 宏

状态引擎

状态引擎基于生成的事件执行状态函数。转换映射是SM_StateStruct类索引的实例。currentState 变量。当_SM_StateEngine()函数中查找正确的状态函数。SM_StateStruct阵列。在状态函数有机会执行之后，它会释放事件数据(如果有的话)，然后再检查是否有任何内部事件是通过SM_InternalEvent().

 
 
 
 
    
  
  
  
  
  1. // The state engine executes the state machine states  
    2.   
  
  
  
  2. void _SM_StateEngine(SM_StateMachine* self, SM_StateMachineConst* selfConst)  
    3.   
  
  
  
  3. {  
    4.   
  
  
  
  4.  void* pDataTemp = NULL;   
    5.   
  
  
  
  5.  ASSERT_TRUE(self);  
    6.   
  
  
  
  6.  ASSERT_TRUE(selfConst);  
    7.   
  
  
  
  7.  // While events are being generated keep executing states  
    8.   
  
  
  
  8.  while (self->eventGenerated)  
    9.   
  
  
  
  9.  {  
    10.   
  
  
  
  10.   // Error check that the new state is valid before proceeding  
    11.   
  
  
  
  11.   ASSERT_TRUE(self->newState < selfConst->maxStates);  
    12.   
  
  
  
  12.   // Get the pointers from the state map  
    13.   
  
  
  
  13.   SM_StateFunc state = selfConst->stateMap[self->newState].pStateFunc;  
    14.   
  
  
  
  14.   // Copy of event data pointer  
    15.   
  
  
  
  15.   pDataTemp = self->pEventData;   
    16.   
  
  
  
  16.   // Event data used up, reset the pointer  
    17.   
  
  
  
  17.   self->pEventData = NULL;  
    18.   
  
  
  
  18.   // Event used up, reset the flag 
    19.   
  
  
  
  19.    self->eventGenerated = FALSE;  
    20.   
  
  
  
  20.   // Switch to the new current state  
    21.   
  
  
  
  21.   self->currentState = self->newState;  
    22.   
  
  
  
  22.   // Execute the state action passing in event data  
    23.   
  
  
  
  23.   ASSERT_TRUE(state != NULL);  
    24.   
  
  
  
  24.   state(self, pDataTemp);  
    25.   
  
  
  
  25.   // If event data was used, then delete it  
    26.   
  
  
  
  26.   if (pDataTemp)  
    27.   
  
  
  
  27.   {  
    28.   
  
  
  
  28.    SM_XFree(pDataTemp);  
    29.   
  
  
  
  29.    pDataTemp = NULL;  
    30.   
  
  
  
  30.   }  
    31.   
  
  
  
  31.  }  
    32.   
  
  
  
  32. } 
    33.

用于保护、入口、状态和退出操作的状态引擎逻辑由以下顺序表示。这个_SM_StateEngine()引擎只实现下面的#1和#5。扩展_SM_StateEngineEx()引擎使用整个逻辑序列。

评估状态转换表。如果EVENT_IGNORED，则忽略事件而不执行转换。如果CANNOT_HAPPEN软件故障。否则，继续下一步。如果定义了保护条件，则执行保护条件函数。如果保护条件返回FALSE，则忽略状态转换而不调用状态函数。如果卫兵回来TRUE，或者如果不存在保护条件，则执行状态函数。如果为当前状态定义了转换到新状态并定义了退出操作，则调用当前状态退出操作函数。如果为新状态定义了转换到新状态并定义了条目操作，则调用新的状态条目操作函数。调用新状态的状态动作函数。新的状态现在是当前的状态。

生成事件

此时，我们有一个工作状态机。让我们看看如何为它生成事件。通过动态创建事件数据结构生成外部事件。SM_XAlloc()，分配结构成员变量，并使用SM_Event()宏。下面的代码片段显示了如何进行同步调用。

 
 
 
 
    
  
  
  
  
  1. MotorData* data;    
    2.   
  
  
  
  2. // Create event data  
    3.   
  
  
  
  3. data = SM_XAlloc(sizeof(MotorData));  
    4.   
  
  
  
  4. data->speed = 100;   
    5.   
  
  
  
  5. // Call MTR_SetSpeed event function to start motor  
    6.   
  
  
  
  6. SM_Event(Motor1SM, MTR_SetSpeed, data); 
    7.

这个SM_Event()第一个参数是状态机名称。第二个参数是要调用的事件函数。第三个参数是事件数据，或者NULL 如果没有数据。

若要从状态函数内生成内部事件，请调用SM_InternalEvent()。如果目标不接受事件数据，那么最后一个参数是NULL。否则，使用SM_XAlloc().

 
 
 
 
    
  
  
  
  
  1. SM_InternalEvent(ST_IDLE, NULL); 
    2.

在上面的示例中，状态函数完成执行后，状态机将转换为ST_Idle状态。另一方面，如果需要将事件数据发送到目标状态，则需要在堆上创建数据结构并作为参数传入。

 
 
 
 
    
  
  
  
  
  1. MotorData* data;    
    2.   
  
  
  
  2. data = SM_XAlloc(sizeof(MotorData));  
    3.   
  
  
  
  3. data->speed = 100;  
    4.   
  
  
  
  4. SM_InternalEvent(ST_CHANGE_SPEED, data); 
    5.

不使用堆

必须动态创建所有状态机事件数据。然而，在某些系统上，使用堆是不可取的。包括x_allocator模块是一个固定的块内存分配程序，它消除了堆的使用。定义USE_SM_ALLOCATOR内_StateMachine.c_若要使用固定块分配器，请执行以下操作。见参考文献下面一节x_allocator信息。

离心机测试实例

这个CentrifugeTest 示例演示如何使用保护、入口和退出操作创建扩展状态机。

A CentrifgeTest 对象和状态机被创建。这里唯一的区别是状态机是一个单例，意味着对象是private只有一个例子CentrifugeTest 可以被创造出来。这与Motor 允许多个实例的状态机。

 
 
 
 
    
  
  
  
  
  1. // CentrifugeTest object structure  
    2.   
  
  
  
  2. typedef struct  
    3.   
  
  
  
  3. {  
    4.   
  
  
  
  4.   INT speed;  
    5.   
  
  
  
  5.   BOOL pollActive;  
    6.   
  
  
  
  6. } CentrifugeTest;   
    7.   
  
  
  
  7. // Define private instance of motor state machine  
    8.   
  
  
  
  8. CentrifugeTest centrifugeTestObj;  
    9.   
  
  
  
  9. SM_DEFINE(CentrifugeTestSM, ¢rifugeTestObj) 
    10.

扩展状态机使用ENTRY_DECLARE, GUARD_DECLARE和EXIT_DECLARE 宏。

 
 
 
 
    
  
  
  
  
  1. // State enumeration order must match the order of state  
    2.   
  
  
  
  2. // method entries in the state map  
    3.   
  
  
  
  3. enum States  
    4.   
  
  
  
  4. {  
    5.   
  
  
  
  5.   ST_IDLE,  
    6.   
  
  
  
  6.   ST_COMPLETED,  
    7.   
  
  
  
  7.   ST_FAILED,  
    8.   
  
  
  
  8.   ST_START_TEST,  
    9.   
  
  
  
  9.   ST_ACCELERATION,  
    10.   
  
  
  
  10.   ST_WAIT_FOR_ACCELERATION,  
    11.   
  
  
  
  11.   ST_DECELERATION,  
    12.   
  
  
  
  12.   ST_WAIT_FOR_DECELERATION,  
    13.   
  
  
  
  13.   ST_MAX_STATES  
    14.   
  
  
  
  14. };  
    15.   
  
  
  
  15. // State machine state functions  
    16.   
  
  
  
  16. STATE_DECLARE(Idle, NoEventData)  
    17.   
  
  
  
  17. ENTRY_DECLARE(Idle, NoEventData)  
    18.   
  
  
  
  18. STATE_DECLARE(Completed, NoEventData)  
    19.   
  
  
  
  19. STATE_DECLARE(Failed, NoEventData)  
    20.   
  
  
  
  20. STATE_DECLARE(StartTest, NoEventData)  
    21.   
  
  
  
  21. GUARD_DECLARE(StartTest, NoEventData)  
    22.   
  
  
  
  22. STATE_DECLARE(Acceleration, NoEventData)  
    23.   
  
  
  
  23. STATE_DECLARE(WaitForAcceleration, NoEventData)  
    24.   
  
  
  
  24. EXIT_DECLARE(WaitForAcceleration)  
    25.   
  
  
  
  25. STATE_DECLARE(Deceleration, NoEventData)  
    26.   
  
  
  
  26. STATE_DECLARE(WaitForDeceleration, NoEventData)  
    27.   
  
  
  
  27. EXIT_DECLARE(WaitForDeceleration)  
    28.   
  
  
  
  28. // State map to define state function order  
    29.   
  
  
  
  29. BEGIN_STATE_MAP_EX(CentrifugeTest)  
    30.   
  
  
  
  30.   STATE_MAP_ENTRY_ALL_EX(ST_Idle, 0, EN_Idle, 0)  
    31.   
  
  
  
  31.   STATE_MAP_ENTRY_EX(ST_Completed)  
    32.   
  
  
  
  32.   STATE_MAP_ENTRY_EX(ST_Failed)  
    33.   
  
  
  
  33.   STATE_MAP_ENTRY_ALL_EX(ST_StartTest, GD_StartTest, 0, 0)  
    34.   
  
  
  
  34.   STATE_MAP_ENTRY_EX(ST_Acceleration)  
    35.   
  
  
  
  35.   STATE_MAP_ENTRY_ALL_EX(ST_WaitForAcceleration, 0, 0, EX_WaitForAcceleration)  
    36.   
  
  
  
  36.   STATE_MAP_ENTRY_EX(ST_Deceleration)  
    37.   
  
  
  
  37.   STATE_MAP_ENTRY_ALL_EX(ST_WaitForDeceleration, 0, 0, EX_WaitForDeceleration)  
    38.   
  
  
  
  38. END_STATE_MAP_EX(CentrifugeTest) 
    39.

注意_EX扩展状态映射宏，从而支持保护/进入/退出功能。每个警卫/出入口DECLARE 宏必须与DEFINE。例如，StartTest 国家职能声明为：

 
 
 
 
    
  
  
  
  
  1. GUARD_DECLARE(StartTest, NoEventData) 
    2.

保护条件函数返回TRUE 如果要执行状态函数或FALSE 不然的话。

 
 
 
 
    
  
  
  
  
  1. // Guard condition to determine whether StartTest state is executed.  
    2.   
  
  
  
  2. GUARD_DEFINE(StartTest, NoEventData)  
    3.   
  
  
  
  3. {  
    4.   
  
  
  
  4.   printf("%s GD_StartTestn", self->name);  
    5.   
  
  
  
  5.   if (centrifugeTestObj.speed == 0)  
    6.   
  
  
  
  6.     return TRUE;  // Centrifuge stopped. OK to start test.  
    7.   
  
  
  
  7.   else  
    8.   
  
  
  
  8.     return FALSE;  // Centrifuge spinning. Can't start test.  
    9.   
  
  
  
  9. } 
    10.

多线程安全

若要防止状态机正在执行过程中由另一个线程抢占，请将StateMachine 模块可以在_SM_ExternalEvent()功能。在允许执行外部事件之前，可以锁定信号量。在处理了外部事件和所有内部事件后，释放了软件锁，允许另一个外部事件进入状态机实例。

注释指出，如果应用程序是多线程的，则应将锁和解锁放在何处。_和_多个线程能够访问单个状态机实例。注意每个StateMachine 对象应该有自己的软件锁实例。这将防止单个实例锁定并阻止所有其他实例。StateMachine对象执行。只有在下列情况下才需要软件锁：StateMachine 实例由多个控制线程调用。如果没有，则不需要锁。

结语

使用此方法实现状态机，而不是旧方法switch语句风格似乎是额外的努力。然而，回报在于一个更健壮的设计，能够在整个多线程系统上统一使用。让每一种状态都具有自己的功能，比单个巨大的状态更容易读取。switch语句，并允许向每个状态发送唯一的事件数据。此外，通过消除不必要的状态转换所造成的副作用，验证状态转换可以防止客户端滥用。

当前题目：C语言中的状态机设计深入讲解
文章来源：http://www.36103.cn/qtweb/news14/14314.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

服务器托管知识

行业网站建设

网站建设改版　　 　尊格展览　　 　成都光华机房服务器托管　　 　成都电商网站建设方案　　 　禾巨建站　　 　成都广告制作　　 　南京护栏钻孔机　　 　网站收录　　 　成都网页设计　　 　达州服务器托管　　 　网站seo优化　　 　成都品牌网站设计　　 　软文平台　　 　网站建设公司　　 　中国电信西部信息中心机房　　 　成都多线服务器托管　　 　云主机　　 　微信开发　　 　成都网站优化　　 　成都网站建设公司