状态机框架

AUTHOR
Version 0.1alpha

Table of Contents

Table of contents

Deprecated List
Global _clearPreloaderOverFlag  (FSM *pFSM)
弃用  
Global _getPreloaderOverFlag  (FSM *pFSM)
弃用  
Global _preloaderGetReady  (FSM *pFSM)
弃用  
Global _preloadIn  (FSM *pFSM)
弃用  
Global ClearPreloaderOverFlag  (pFSM)
  
Global FSMDataLoader  
预装载器弃用 
Global FSMHandler::childFSMStepTable  )(FSM **cFSM)
子状态机暂时弃用  
Global FSMPrivateVars::childFSM  
和子状态机相关的暂时弃用  
Global FSMPrivateVars::numChild  
和子状态机相关的暂时弃用  
Global FSMPrivateVars::preloader  
弃用  
Global FSMPureVtbl::initDataLoader  )(FSM *pFSM)
和预装载器相关  
Global FSMPureVtbl::loadExternalData  )(void *extData)
暂时没用，后续可能考虑外部数据是否允许随时修改  
Global GetPreloaderOverFlag  (pFSM)
  
Global initDataLoader  (TemplateFSM *pFSM)
弃用  
Global loadExternalData  (TemplateFSMData *data)
暂时没用，后续考虑data是否需要加锁再说  
Global preload  (FSM *pFSM)
去掉了所有和预装载器相关的内容  
Global PreloaderGetReady  (pFSM)
  
Global TemplateFSM_Input  (pFSM)
暂时弃用 

Data Structure Index
Data Structures
Here are the data structures with brief descriptions:
FSMDataLoader  	pagenum
FSMHandler (状态处理函数集合，全部需要子类重新填充内容 ) 	pagenum
FSMPrivateVars (基类状态机的私有变量和函数，子类不可直接访问 ) 	pagenum
FSMPureVtbl (纯虚函数，子类必须重新实现，父类构造函数不会初始化 ) 	pagenum
FSMSignals (状态机用的信号，protected子类可以访问 ) 	pagenum
TemplateFSMExternalData (自定义外部数据 ) 	pagenum
TemplateFSMInnerData (自定义内部数据 ) 	pagenum

File Index
File List
Here is a list of all documented files with brief descriptions:
FSM_OOP/baseFSM/FSM.c  	pagenum
FSM_OOP/baseFSM/FSM_private.h (状态机框架的私有变量，只能在状态机框架内使用。 ) 	pagenum
FSM_OOP/baseFSM/FSM_protected.h (状态机框架的protected函数和变量，在继承的子类中可使用，在外界不可使用 ) 	pagenum
FSM_OOP/baseFSM/FSM_public.h  	pagenum
FSM_OOP/childtest/childFSM.h  	pagenum
FSM_OOP/childtest/childFSM_private.h  	pagenum
FSM_OOP/childtest/parentFSM.h  	pagenum
FSM_OOP/keytest/keyFSM.h  	pagenum
FSM_OOP/keytest/keyFSM_private.h  	pagenum
FSM_OOP/template/templateFSM.c (重新实现几个必须实现的函数，并赋值到父类指针里 ) 	pagenum
FSM_OOP/template/templateFSM.h (对外暴露接口，外部可以设置状态机的信号 ) 	pagenum
FSM_OOP/template/templateFSM_private.h (用来声明状态、状态函数等。这个文件只能被templateFSM.c引用一次！ ) 	pagenum

Data Structure Documentation
FSMDataLoader Struct Reference

#include <FSM_private.h>

Detailed Description

Deprecated:
预装载器弃用

FSMHandler Struct Reference

状态处理函数集合，全部需要子类重新填充内容 
#include <FSM_protected.h>
Data Fields
int(** selectNextState )(void *data, FSMSignals *signals)
void(** transitionTable )(void *data)
void(* transitionGeneralAction )(void *data)
void(** enterActionTable )(void *data, FSM **cFSM)
void(** duringActionTable )(void *data, FSM **cFSM)
void(** exitActionTable )(void *data, FSM **cFSM)
void(** childFSMStepTable )(FSM **cFSM)

Detailed Description
状态处理函数集合，全部需要子类重新填充内容 
这个结构体是私有变量，子状态机和外界都不该访问。但是写在FSM_protect.h文件，这样方便在子类中添加函数。不然添加函数得再写个函数添加， 有点麻烦 

Field Documentation
int(** FSMHandler::selectNextState) (void *data, FSMSignals *signals)
每个状态配置的状态选择函数 
void(** FSMHandler::transitionTable) (void *data)
状态转移函数表 
void(* FSMHandler::transitionGeneralAction) (void *data)
通用状态转移函数，不论有没有独立的状态转移函数都会执行 
void(** FSMHandler::enterActionTable) (void *data, FSM **cFSM)
进入状态时运行的函数，和plecs对标 
void(** FSMHandler::duringActionTable) (void *data, FSM **cFSM)
状态不变时运行的函数，和plecs对标 
void(** FSMHandler::exitActionTable) (void *data, FSM **cFSM)
状态退出时运行的函数，和plecs对标 
void(** FSMHandler::childFSMStepTable) (FSM **cFSM)

Deprecated:
子状态机暂时弃用 

FSMPrivateVars Struct Reference

基类状态机的私有变量和函数，子类不可直接访问 
#include <FSM_private.h>
Data Fields
int numState
int defaultState
int curState
int nextState
int index
FSMHandler fcns
int numChild
FSM ** childFSM
FSMDataLoader preloader

Detailed Description
基类状态机的私有变量和函数，子类不可直接访问 

Field Documentation
int FSMPrivateVars::numState
状态数量 
int FSMPrivateVars::defaultState
Idle状态不能停留，必须指定一个初始状态 
int FSMPrivateVars::curState
当前状态 
int FSMPrivateVars::nextState
nextState为Idle代表状态机不发生变化 
int FSMPrivateVars::index
状态转移函数表对应的标号 
FSMHandler FSMPrivateVars::fcns
状态函数表 
int FSMPrivateVars::numChild

Deprecated:
和子状态机相关的暂时弃用 
FSM** FSMPrivateVars::childFSM

Deprecated:
和子状态机相关的暂时弃用 
FSMDataLoader FSMPrivateVars::preloader

Deprecated:
弃用 

FSMPureVtbl Struct Reference

纯虚函数，子类必须重新实现，父类构造函数不会初始化 
#include <FSM_protected.h>
Data Fields
void(* setupHandler )(FSMHandler *fcns)
void(* initData )(FSM *pFSM)
void(* loadExternalData )(void *extData)
void(* initDataLoader )(FSM *pFSM)
void(* initSignals )(FSM *pFSM)
void(* resetSignals )(FSMSignals *signals, void *data)

Detailed Description
纯虚函数，子类必须重新实现，父类构造函数不会初始化 

Field Documentation
void(* FSMPureVtbl::setupHandler) (FSMHandler *fcns)
设置所有的FSMHandler，必须重新实现 
void(* FSMPureVtbl::initData) (FSM *pFSM)
初始化状态机用数据，包括内部数据和外部数据 
void(* FSMPureVtbl::loadExternalData) (void *extData)

Deprecated:
暂时没用，后续可能考虑外部数据是否允许随时修改 
void(* FSMPureVtbl::initDataLoader) (FSM *pFSM)

Deprecated:
和预装载器相关 
void(* FSMPureVtbl::initSignals) (FSM *pFSM)
初始化状态机信号 
void(* FSMPureVtbl::resetSignals) (FSMSignals *signals, void *data)
根据条件重置状态机信号 

FSMSignals Struct Reference

状态机用的信号，protected子类可以访问 
#include <FSM_protected.h>
Data Fields
Uint16 all
Uint16 lastTriggeredSignal

Detailed Description
状态机用的信号，protected子类可以访问 
外部只能通过SetSignal函数对信号进行设置，在状态机运行时会根据信号清除函数清除信号。信号 利用位进行存储，每个位代表一个信号，通过移位操作设置和清除信号。 

Field Documentation
Uint16 FSMSignals::all
外部信号 
Uint16 FSMSignals::lastTriggeredSignal
上一次触发的外部信号，用于信号清除 

TemplateFSMExternalData Struct Reference

自定义外部数据 
#include <templateFSM.h>

Detailed Description
自定义外部数据 

TemplateFSMInnerData Struct Reference

自定义内部数据 
#include <templateFSM.h>

Detailed Description
自定义内部数据 

File Documentation
FSM_OOP/baseFSM/FSM.c File Reference
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include "FSM_private.h"
#include "FSM_protected.h"
#include "FSM_public.h"
Functions
static void setNextState (FSM *pFSM)
设置下一个状态，里面的子状态机暂时没用到 

static void preload (FSM *pFSM)
void stepBaseFSM (FSM *pFSM)
运行状态机，状态机框架的核心函数 

void * _preloadIn (FSM *pFSM)
void _preloaderGetReady (FSM *pFSM)
int _getPreloaderOverFlag (FSM *pFSM)
void _clearPreloaderOverFlag (FSM *pFSM)

Detailed Description

Author
天神 (dalaoshi@stu.xjtu.edu.cn) 
Version
2.1 
Date
2024-05-07
Copyright
天神创意无限公司 2024 

Function Documentation
static void setNextState (FSM *  pFSM)[inline], [static]

设置下一个状态，里面的子状态机暂时没用到 

Parameters
pFSM 	状态机变量的基类指针 	
static void preload (FSM *  pFSM)[inline], [static]

Deprecated:
去掉了所有和预装载器相关的内容 
Parameters
pFSM 		
void stepBaseFSM (FSM *  pFSM)

运行状态机，状态机框架的核心函数 
共分为三部首先判断是否有状态机切换， 
Parameters
pFSM 	状态机基类指针 	
void * _preloadIn (FSM *  pFSM)

Deprecated:
弃用 
Parameters
pFSM 		
Returns
void* 
void _preloaderGetReady (FSM *  pFSM)

Deprecated:
弃用 
Parameters
pFSM 		
int _getPreloaderOverFlag (FSM *  pFSM)

Deprecated:
弃用 
Parameters
pFSM 		
Returns
int 
void _clearPreloaderOverFlag (FSM *  pFSM)

Deprecated:
弃用 
Parameters
pFSM 		

FSM_OOP/baseFSM/FSM_private.h File Reference

状态机框架的私有变量，只能在状态机框架内使用。 
#include <string.h>
#include "FSM_protected.h"
Data Structures
struct FSMDataLoaderstruct FSMPrivateVars
基类状态机的私有变量和函数，子类不可直接访问 
Typedefs
typedef struct FSMHandler FSMHandler
状态处理函数集合，全部需要子类重新填充内容 

typedef struct FSMSignals FSMSignals
状态机用的信号，protected子类可以访问 

typedef struct FSMDataLoader FSMDataLoader
typedef struct FSMPrivateVars FSMPrivateVars
基类状态机的私有变量和函数，子类不可直接访问 

Functions
FSMPrivateVars * newFMSPrivateVars (int numState, int defaultState)
仅在FSM.c中调用，新建私有变量并分配空间 

Detailed Description
状态机框架的私有变量，只能在状态机框架内使用。 

Author
天神 (dalaoshi@stu.xjtu.edu.cn)
基类私有变量对子类和外界隐藏实现，通过指针进行访问。 
Version
2.1 
Date
2024-05-07
Copyright
天神创意无限公司 2024 

Typedef Documentation
typedef struct FSMHandler FSMHandler

状态处理函数集合，全部需要子类重新填充内容 
这个结构体是私有变量，子状态机和外界都不该访问。但是写在FSM_protect.h文件，这样方便在子类中添加函数。不然添加函数得再写个函数添加， 有点麻烦 
typedef struct FSMSignals FSMSignals

状态机用的信号，protected子类可以访问 
外部只能通过SetSignal函数对信号进行设置，在状态机运行时会根据信号清除函数清除信号。信号 利用位进行存储，每个位代表一个信号，通过移位操作设置和清除信号。 
typedef struct FSMDataLoader FSMDataLoader

Deprecated:
预装载器弃用

Function Documentation
FSMPrivateVars * newFMSPrivateVars (int  numState, int  defaultState)

仅在FSM.c中调用，新建私有变量并分配空间 

Parameters
numState 		
defaultState 		
Returns
FSMPrivateVars* 

FSM_private.h
Go to the documentation of this file.
1 
14 #ifndef __FSM_PRIVATE_H_
15 #define __FSM_PRIVATE_H_
16 
17 #include <string.h>
18 #include "FSM_protected.h"
19 
20 typedef struct FSMHandler FSMHandler;
21 typedef struct FSM FSM;
22 typedef struct FSMSignals FSMSignals;
23 
24 /* -------------------------------------------------------------------------- */
25 /*                             private数据类型                                */
26 /* -------------------------------------------------------------------------- */
32 typedef struct FSMDataLoader
33 {   
34     void *shadowData;
35     int isReady;
36     int isOverflow;
37     size_t size;
38 }FSMDataLoader;
39 
40 
45 typedef struct FSMPrivateVars
46 {
47     int numState;  
48     int defaultState; 
50     int curState;    
51     int nextState;   
52     int index;  
54     FSMHandler fcns;    
56     int numChild;        
57     FSM **childFSM;     
59     FSMDataLoader preloader;    
61 }FSMPrivateVars;
62 
63 
64 
72 FSMPrivateVars* newFMSPrivateVars(int numState, int defaultState){
73     typedef void (*StateFuncPtr)(void *); 
74     typedef void (*ChildFSMStepFuncPtr)(FSM **); 
75     typedef int (*TransitionFuncPtr)(void *, int *);
76     typedef int (*SelectNextStateFcnPtr)(void *, FSMSignals *);
77 
78     FSMPrivateVars *privateVars = calloc(1, sizeof(FSMPrivateVars));
79     privateVars->numState = numState;
80     privateVars->defaultState = defaultState;
81     privateVars->curState = 0;
82     privateVars->nextState = 0;
83     privateVars->numChild = 0;
84 
85     privateVars->preloader.isReady = 0;
86 
87     privateVars->fcns.duringActionTable = calloc(numState,  sizeof(StateFuncPtr));
88     privateVars->fcns.enterActionTable = calloc(numState, sizeof(StateFuncPtr));
89     privateVars->fcns.exitActionTable = calloc(numState, sizeof(StateFuncPtr));
90     
91     privateVars->fcns.selectNextState = calloc(numState, sizeof(SelectNextStateFcnPtr));
92     privateVars->fcns.transitionTable = calloc(numState * numState, sizeof(TransitionFuncPtr));
93     privateVars->fcns.transitionGeneralAction = calloc(1, sizeof(StateFuncPtr));
94 
95     privateVars->fcns.childFSMStepTable = calloc(numState * numState, sizeof(ChildFSMStepFuncPtr));
96     
97     return privateVars;
98 }
99 
100 #endif

FSM_OOP/baseFSM/FSM_protected.h File Reference

状态机框架的protected函数和变量，在继承的子类中可使用，在外界不可使用 
#include "FSM_public.h"
Data Structures
struct FSMHandler状态处理函数集合，全部需要子类重新填充内容 
struct FSMSignals状态机用的信号，protected子类可以访问 
struct FSMPureVtbl纯虚函数，子类必须重新实现，父类构造函数不会初始化 
Macros
#define Idle_Signal  0
Typedefs
typedef struct FSMHandler FSMHandler
状态处理函数集合，全部需要子类重新填充内容 

typedef struct FSMSignals FSMSignals
状态机用的信号，protected子类可以访问 

typedef struct FSMPureVtbl FSMPureVtbl
纯虚函数，子类必须重新实现，父类构造函数不会初始化 

Functions
void stepBaseFSM (FSM *pFSM)
运行状态机，状态机框架的核心函数 

Detailed Description
状态机框架的protected函数和变量，在继承的子类中可使用，在外界不可使用 

Author
天神 (dalaoshi@stu.xjtu.edu.cn) 
Version
2.1 
Date
2024-05-07
Copyright
天神创意无限公司 2024 

Macro Definition Documentation
#define Idle_Signal  0
清空上次触发信号，占用第一个信号位 

Typedef Documentation
typedef struct FSMHandler FSMHandler

状态处理函数集合，全部需要子类重新填充内容 
这个结构体是私有变量，子状态机和外界都不该访问。但是写在FSM_protect.h文件，这样方便在子类中添加函数。不然添加函数得再写个函数添加， 有点麻烦 
typedef struct FSMSignals FSMSignals

状态机用的信号，protected子类可以访问 
外部只能通过SetSignal函数对信号进行设置，在状态机运行时会根据信号清除函数清除信号。信号 利用位进行存储，每个位代表一个信号，通过移位操作设置和清除信号。 

Function Documentation
void stepBaseFSM (FSM *  pFSM)

运行状态机，状态机框架的核心函数 
共分为三部首先判断是否有状态机切换， 
Parameters
pFSM 	状态机基类指针 	

FSM_protected.h
Go to the documentation of this file.
1 
12 #ifndef __FSM_PROTECTED_H_
13 #define __FSM_PROTECTED_H_
14 
15 #include "FSM_public.h"
16 
17 // #define DSP28377
18 #ifdef      DSP28377
19     #define     NDEBUG
20 #else
21     #define     FSM_LOG_ON
22 #endif
23 
24 
25 #ifdef          FSM_LOG_ON
26     #define     FSM_LOG(...)   printf(__VA_ARGS__)
27 #else
28     #define     FSM_LOG(...)   ((void)0)
29 #endif
30 
31 #define     during  during
32 #define     enter   enter
33 #define     exit    exit
34 
35 #define     selectNextStateFcn(curstate)                       curstate##_##selectNextState
36 #define     transitionHandler(curstate, nextstate)             curstate##2##nextstate##Handler
37 #define     actionFcn(action, curstate)                        curstate##_##action##Action
38 #define     index(curstate, nextstate)                         (curstate*Count_State + nextstate)
39 
40 #define     addSelectNextStateFcn(curstate)                         fcns->selectNextState[curstate] = (Avoid_WARNING_SelectNextState)selectNextStateFcn(curstate)
41 #define     addStateActionFcn(type, state)                          fcns->type##ActionTable[state] = (Avoid_WARNING_State_Fcns)actionFcn(type, state)
42 #define     addTransitionHandler(curstate, nextstate)               fcns->transitionTable[index(curstate, nextstate)] = (Avoid_WARNING_Transition_Handler)transitionHandler(curstate, nextstate)
43 
44 
45 
46 typedef struct FSMHandler FSMHandler;
47 typedef struct FSM FSM;
48 typedef struct FSMSignals FSMSignals;
49 typedef struct FSMPrivateVars FSMPrivateVars;
50 
51 typedef void (*Avoid_WARNING_State_Fcns)(void *data, FSM **childFSM);
52 typedef void (*Avoid_WARNING_General_Handlers)(void *data);
53 typedef void (*Avoid_WARNING_Transition_Handler)(void *data);
54 typedef void (*Avoid_WARNING_Overrider_Fcns)(FSM *pFSM);
55 typedef void (*Avoid_WARNING_ResetSignals_Fcns)(FSMSignals* signals, void *);
56 typedef void (*Avoid_WARNING_loadData_Fcns)(void*);
57 typedef int (*Avoid_WARNING_SelectNextState)(void *data, FSMSignals* signals);
58 typedef void (*Avoid_WARNING_void_fcns)(FSMHandler *fcns);
59 
60 
67 typedef struct FSMHandler{
68     int (**selectNextState)(void *data, FSMSignals* signals); 
70     void (**transitionTable)(void *data);    
71     void (*transitionGeneralAction)(void *data);    
73     void (**enterActionTable)(void *data, FSM **cFSM);  
74     void (**duringActionTable)(void *data, FSM **cFSM); 
75     void (**exitActionTable)(void *data, FSM **cFSM); 
77     void (**childFSMStepTable)(FSM **cFSM); 
78 }FSMHandler;
79 
85 typedef struct FSMSignals
86 {
87     Uint16 all;    
88     Uint16 lastTriggeredSignal; 
89 }FSMSignals;
90 #define     Idle_Signal     0   
92 /* -------------------------------------------------------------------------- */
93 /*             纯虚函数，子类必须重新实现，父类构造函数不会初始化               */
94 /* -------------------------------------------------------------------------- */
95 
100 typedef struct FSMPureVtbl {
101     // 状态机控制
102     void (*setupHandler)(FSMHandler *fcns);    
104     void (*initData)(FSM *pFSM);    
105     void (*loadExternalData)(void *extData);    
107     void (*initDataLoader)(FSM *pFSM);    
109     void (*initSignals)(FSM *pFSM);    
110     void (*resetSignals)(FSMSignals *signals, void *data);   
111 }FSMPureVtbl;
112 
113 
114 
115 /* -------------------------------------------------------------------------- */
116 /*                          基类定义，纯虚类                                  */
117 /* -------------------------------------------------------------------------- */
118 typedef struct FSM
119 {
120     FSMPublicFcns publicFcns;
121     // protected
122     FSMPureVtbl pureVtbl;
123     
124     void *data;
125     FSMSignals signals;
126     // private
127     FSMPrivateVars* privateVars; 
128 } FSM;
129 
130 
131 /* -------------------------------------------------------------------------- */
132 /*                    protected函数，子类能用外界用不了                        */
133 /* -------------------------------------------------------------------------- */
134 void stepBaseFSM(FSM *pFSM);
135 void constructFSM(FSM* pFSM);
136 FSM*  newBaseFSM(int numState, int defaultState);
137 void resetBaseFSM(FSM *pFSM);
138 
139 
140 /* -------------------------------------------------------------------------- */
141 /*                               内联函数                                    */
142 /* -------------------------------------------------------------------------- */
143 static inline void clearSignal(FSMSignals *signals, Uint16 signalFlag){
144     signals->all &= ~(1 << signalFlag);
145 }
146 static inline Uint16 getSignal(FSMSignals *signals, Uint16 signalFlag){
147     return (signals->all >> signalFlag) & 1;
148 }
149 static inline void clearAllSignals(FSMSignals *signals){
150     signals->all = 0;
151 }
152 
153 
154 #endif

FSM_OOP/baseFSM/FSM_public.h File Reference
Macros
#define Step(pFSM)  _stepFSM((FSM *)pFSM)
#define GetData(pFSM)  _getData((FSM*)pFSM)
#define SetSignal(pFSM,  signal)  _setSignal((FSM*)pFSM, signal)
#define PreloaderGetReady(pFSM)  _preloaderGetReady((FSM *)pFSM);
#define GetPreloaderOverFlag(pFSM)  _getPreloaderOverFlag((FSM *)pFSM)
#define ClearPreloaderOverFlag(pFSM)  _clearPreloaderOverFlag((FSM *)pFSM)
Functions
void * _preloadIn (FSM *pFSM)
void _preloaderGetReady (FSM *pFSM)
int _getPreloaderOverFlag (FSM *pFSM)
void _clearPreloaderOverFlag (FSM *pFSM)

Detailed Description

Author
天神 (dalaoshi@stu.xjtu.edu.cn) 
Version
2.1 
Date
2024-05-07
Copyright
天神创意无限公司 2024 

Macro Definition Documentation
#define Step( pFSM)  _stepFSM((FSM *)pFSM)
外界调用这个 
#define GetData( pFSM)  _getData((FSM*)pFSM)
外界调用这个 
#define SetSignal( pFSM,  signal)  _setSignal((FSM*)pFSM, signal)
外界调用这个 
#define PreloaderGetReady( pFSM)  _preloaderGetReady((FSM *)pFSM);

Deprecated:

#define GetPreloaderOverFlag( pFSM)  _getPreloaderOverFlag((FSM *)pFSM)

Deprecated:

#define ClearPreloaderOverFlag( pFSM)  _clearPreloaderOverFlag((FSM *)pFSM)

Deprecated:

Function Documentation
void * _preloadIn (FSM *  pFSM)

Deprecated:
弃用 
Parameters
pFSM 		
Returns
void* 
void _preloaderGetReady (FSM *  pFSM)

Deprecated:
弃用 
Parameters
pFSM 		
int _getPreloaderOverFlag (FSM *  pFSM)

Deprecated:
弃用 
Parameters
pFSM 		
Returns
int 
void _clearPreloaderOverFlag (FSM *  pFSM)

Deprecated:
弃用 
Parameters
pFSM 		

FSM_public.h
Go to the documentation of this file.
1 
11 #ifndef __FSM_PUBLIC_H_
12 #define __FSM_PUBLIC_H_
13 
14 typedef unsigned int       Uint16;
15 typedef unsigned long        Uint32;
16 
17 #define     BASE_FSM(ptr)          ((FSM *)(ptr))
18 #define     BASE_PTR               (FSM *)
19 
20 typedef struct FSM FSM;
21 
22 typedef struct FSMPublicFcns
23 {
24     void (*step)(FSM *pFSM);    // 子类重新实现可以添加一些打印信息
25     void (*reset)(FSM *pFSM);   // 子类重新实现可以添加一些打印信息
26 
27 }FSMPublicFcns;
28 
29 /* -------------------------------- 避免警告的函数定义 ------------------------------- */
30 #define     Step(pFSM)                       _stepFSM((FSM *)pFSM) 
31 #define     GetData(pFSM)                    _getData((FSM*)pFSM)  
32 #define     SetSignal(pFSM, signal)          _setSignal((FSM*)pFSM, signal)  
35 #define     PreloaderGetReady(pFSM)          _preloaderGetReady((FSM *)pFSM);   
36 #define     GetPreloaderOverFlag(pFSM)       _getPreloaderOverFlag((FSM *)pFSM) 
37 #define     ClearPreloaderOverFlag(pFSM)     _clearPreloaderOverFlag((FSM *)pFSM) 
40 void _stepFSM(FSM *pFSM);
41 /* --------------------------------- 状态机信息获取 -------------------------------- */
42 int getFSMCurState(FSM *pFSM);
43 int getFSMNextState(FSM *pFSM);
44 void setChildNum(FSM *pFSM, int num);
45 void registerChildFSM(FSM *parent, FSM *child, int index);
46 
47 /* ------------------------------ Data和Signals ------------------------------ */
48 const void *_getData(FSM* pFSM);
49 void _setSignal(FSM *pFSM, Uint16 signalFlag);
50 
51 /* ---------------------------------- 预装载器 ---------------------------------- */
52 void *_preloadIn(FSM *pFSM);
53 void _preloaderGetReady(FSM *pFSM);
54 int _getPreloaderOverFlag(FSM *pFSM);
55 void _clearPreloaderOverFlag(FSM *pFSM);
56 
57 
58 
59 #endif

childFSM.h
1 #ifndef __CHILD_FSM_H_
2 #define __CHILD_FSM_H_
3 
4 #define     ChildFSM_Input(pFSM)      ((ChildFSMData *)_preloadIn((FSM *)pFSM))
5 
6 typedef struct _childFSMData
7 {
8     int arrindex;
9 }ChildFSMData;
10 
11 typedef struct _ChildFSM ChildFSM;
12 
13 ChildFSM *createChildFSM();
14 
15 
16 
17 #endif

childFSM_private.h
1 #ifndef __CHILD_PRIVATE_FSM_H_
2 #define __CHILD_PRIVATE_FSM_H_
3 
4 #include "FSM_protected.h"
5 #include "childFSM.h"
6 #include <stdio.h>
7 
8 
9 /* 
10     继承基类
11  */
12 typedef struct _ChildFSM
13 {   
14     // 继承父类
15     FSM base;
16 }ChildFSM;
17 
18 /* 
19     状态和对应的 action, exit, during 函数
20  */
21 
22 typedef enum _State
23 {
24     Idle,
25     D,
26     E,
27 
28     Count_State,
29 } State;
30 #define     DEFAULT_STATE       E
31 
32 void actionFcn(enter, D)()
33 {
34     FSM_LOG(" enterD ");
35 }
36 void actionFcn(during, D)()
37 {
38     FSM_LOG(" duringD ");
39 }
40 void actionFcn(exit, D)()
41 {
42     FSM_LOG(" exitD ");
43 }
44 
45 void actionFcn(enter, E)()
46 {
47     FSM_LOG(" enterE ");
48 }
49 void actionFcn(during, E)()
50 {
51     FSM_LOG(" duringE ");
52 }
53 void actionFcn(exit, E)()
54 {
55     FSM_LOG(" exitE ");
56 }
57 
58 /* 
59     事件和对应的转移函数
60  */
61 
62 typedef enum _Event{
63     Idle_Event,
64     Idle2D,
65     Idle2E,
66     D2E,
67     E2D,
68 
69     Count_Event,
70 }Event;
71 
72 
73 State transitionHandler(Idle2D)()
74 {
75     FSM_LOG(" Idle2D ");
76     return D;
77 }
78 
79 State transitionHandler(Idle2E)()
80 {
81     FSM_LOG(" Idle2E ");
82     return E;
83 }
84 
85 State transitionHandler(D2E)()
86 {
87     FSM_LOG(" D2E ");
88     return E;
89 }
90 
91 State transitionHandler(E2D)()
92 {
93     FSM_LOG(" E2D ");
94     return D;
95 }
96 
97 
98 
99 
100 /* 
101     用户自定义事件选择逻辑—————————————————begin 
102 */
103 const static char *stateStr[] = {
104     "Idle",
105     "D",
106     "E",
107     };
108 const static char *eventStr[] = {
109     "Idle",
110     "Idle2D",
111     "Idle2E",
112     "D2E",
113     "E2D",
114 };
115 static void printFSM(ChildFSM* pFSM){
116     FSM_LOG(" \t\tChildFSM: ");
117     FSM_LOG("当前状态:%s, 当前事件:%s, 动作：", stateStr[getFSMCurState((FSM *)pFSM)], eventStr[getFSMCurEvent((FSM *)pFSM)]);
118 }
119 
120 
121 #endif

parentFSM.h
1 #ifndef __PARENT_FSM_H_
2 #define __PARENT_FSM_H_
3 
4 #define     ParentFSM_Input(pFSM)      ((ParentFSMData *)_preloadIn((FSM *)pFSM))
5 
6 typedef struct _parentFSMData
7 {
8     int arrindex;
9 }ParentFSMData;
10 typedef struct _ParentFSM ParentFSM;
11 
12 ParentFSM *createParentFSM();
13 
14 
15 #endif

keyFSM.h
1 #ifndef __KEY_FSM_H_
2 #define __KEY_FSM_H_
3 
4 
5 #define     KeyFSM_Input(pFSM)      (KeyIn *)_preloadIn((FSM *)pFSM)
6 
7 typedef enum _keyIn{
8     pUp,
9     pDown,
10 }KeyIn;
11 
12 
13 typedef enum _keyOut{
14     Idle,
15     Down,
16     Hold,
17     Down_2times,
18     Down_3times,
19 }KeyOut;
20 
21 const static char *keyStr[] = 
22 {
23     "Idle",
24     "Down",
25     "Hold",
26     "Down_2times",
27     "Down_3times",
28 };
29 
30 typedef struct _keyFSMExternalData
31 {
32     KeyIn in;
33 }KeyFSMExternalData;
34 
35 typedef struct _keyFSMInternalData
36 {
37     int countDelay;
38     int countMultiDown;
39     KeyOut out;
40 
41 }KeyFSMInternalData;
42 
43 typedef struct _keyFSMData
44 {
45     KeyFSMExternalData external;
46     KeyFSMInternalData internal;
47 }KeyFSMData;
48 
49 typedef struct _KeyFSM KeyFSM;
50 
51 KeyFSM *createKeyFSM();
52 
53 
54 
55 #endif

keyFSM_private.h
1 #ifndef __KEY_PRIVATE_FSM_H_
2 #define __KEY_PRIVATE_FSM_H_
3 
4 #include "FSM_protected.h"
5 #include "keyFSM.h"
6 #include <stdio.h>
7 #include <assert.h>
8 
9 extern KeyIn keystat;
10 
11 
12 /* 
13     继承基类
14  */
15 typedef struct _KeyFSM
16 {   
17     // 继承父类
18     FSM base;
19 }KeyFSM;
20 
21 /* 
22     状态和对应的 action, exit, during 函数
23  */
24 
25 typedef enum _State
26 {
27     Idle_State,
28     Waiting,
29     DownDebouncing,
30     Downing,
31     Holding,
32     HoldUpDebouncing,
33     UpDebouncing,
34     MultiDownWaiting,
35     MultiDowning,
36     MultiDownDebouncing,
37 
38     Count_State,
39 } State;
40 #define     DEFAULT_STATE       Waiting
41 
42 /* -------------------------------------------------------------------------- */
43 /*                         下一个状态选择函数                                 */
44 /* -------------------------------------------------------------------------- */
45 static State selectNextStateFcn(Waiting)(KeyFSMData *data){
46     
47     if(data->external.in == Down){
48         FSM_LOG(" 物理按键按下 ");
49         return DownDebouncing;
50     }
51     return Idle_State;
52 }
53 
54 static State selectNextStateFcn(DownDebouncing)(KeyFSMData *data){
55     if(data->external.in == pUp){
56         FSM_LOG(" 物理按键松开 ");
57         return Waiting;
58     }
59     
60     else if(data->internal.countDelay == 5){
61         return Downing;
62     }
63     return Idle_State;
64 }
65 
66 static State selectNextStateFcn(Downing)(KeyFSMData *data){
67     if(data->external.in == pUp){
68         FSM_LOG(" 物理按键松开 ");
69         return UpDebouncing;
70     }
71     else if(data->internal.countDelay == 10){
72         return Holding;
73     }
74     return Idle_State;
75 }
76 
77 static State selectNextStateFcn(Holding)(KeyFSMData *data){
78     if(data->external.in == pUp){
79         FSM_LOG(" 物理按键松开 ");
80         return HoldUpDebouncing;
81     }
82     return Idle_State;
83 }
84 
85 static State selectNextStateFcn(HoldUpDebouncing)(KeyFSMData *data){
86     if(data->external.in == Down){
87         FSM_LOG(" 物理按键按下 ");
88         return Holding;
89     }
90     else if(data->internal.countDelay == 5){
91         return Waiting;
92     }
93     return Idle_State;
94 }
95 
96 static State selectNextStateFcn(UpDebouncing)(KeyFSMData *data){
97     if(data->external.in == Down){
98         FSM_LOG(" 物理按键按下 ");
99         if(data->internal.countMultiDown){
100             return MultiDowning;
101         }
102         else{
103             return Downing;
104         }
105     }
106     else if(data->internal.countDelay == 5){
107         return MultiDownWaiting;
108     }
109 
110     return Idle_State;
111 }
112 
113 static State selectNextStateFcn(MultiDownWaiting)(KeyFSMData *data){
114     if(data->external.in == Down){
115         FSM_LOG(" 物理按键按下 ");
116         return MultiDownDebouncing;
117     }
118     else if(data->internal.countDelay == 5){
119         return Waiting;
120     }
121     return Idle_State;
122 }
123 
124 static State selectNextStateFcn(MultiDowning)(KeyFSMData *data){
125     if(data->external.in == pUp){
126         FSM_LOG(" 物理按键松开 ");
127         return UpDebouncing;
128     }
129     return Idle_State;
130 }
131 
132 static State selectNextStateFcn(MultiDownDebouncing)(KeyFSMData *data){
133     if(data->external.in == pUp){
134         FSM_LOG(" 物理按键松开 ");
135         return MultiDownWaiting;
136     }
137     else if(data->internal.countDelay == 5){
138         return MultiDowning;
139     }
140     return Idle_State;
141 }
142 
143 /* -------------------------------------------------------------------------- */
144 /*                    对应的 action, exit, during 函数                        */
145 /* -------------------------------------------------------------------------- */
146 static void actionFcn(enter, Waiting)(KeyFSMData* data){
147     data->internal.out = Idle;
148     data->internal.countDelay = 0;
149     data->internal.countMultiDown = 0;
150 }
151 
152 
153 static void actionFcn(during, DownDebouncing)(KeyFSMData* data)
154 {
155     data->internal.countDelay++;
156     FSM_LOG(" during开启消抖 ");
157 }
158 
159 static void actionFcn(during, Downing)(KeyFSMData* data)
160 {
161  
162     data->internal.countDelay++;
163     data->internal.out = Idle;
164 }
165 
166 
167 
168 static void actionFcn(during, UpDebouncing)(KeyFSMData* data){
169  
170     data->internal.countDelay++;
171     FSM_LOG(" during松开消抖 ");
172 }
173 
174 
175 static void actionFcn(during, Holding)(KeyFSMData* data){
176     data->internal.out = Idle;
177     data->internal.countDelay++;
178     if(data->internal.countDelay == 2){
179         data->internal.out = Hold;
180         data->internal.countDelay = 0;
181     }
182 }
183 
184 static void actionFcn(exit, Holding)(KeyFSMData* data){
185     data->internal.out = Idle;
186 }
187 
188 
189 
190 static void actionFcn(during, MultiDownWaiting)(KeyFSMData* data){
191     data->internal.countDelay++;
192     FSM_LOG(" during多击等待 ");
193 }
194 
195 
196 
197 static void actionFcn(during, HoldUpDebouncing)(KeyFSMData* data)
198 {
199     data->internal.countDelay++;
200 }
201 
202 
203 static void actionFcn(during, MultiDownDebouncing)(KeyFSMData* data)
204 {
205     data->internal.countDelay++;
206 }
207 
208 
209 /* -------------------------------------------------------------------------- */
210 /*                                转移函数                                    */
211 /* -------------------------------------------------------------------------- */
212 void transitionGeneralAction(KeyFSMData *data){
213     data->internal.countDelay = 0;
214 }
215 
216 static State transitionHandler(DownDebouncing, Downing)(KeyFSMData* data){
217     data->internal.out = Down;
218 }
219 
220 
221 static State transitionHandler(UpDebouncing, MultiDownWaiting)(KeyFSMData* data){
222     data->internal.out = Idle;
223     data->internal.countMultiDown++;
224 }
225 
226 static State transitionHandler(MultiDownDebouncing, MultiDowning)(KeyFSMData* data){
227     switch (data->internal.countMultiDown + 1)
228     {
229     case 2:
230         data->internal.out = Down_2times;
231         break;
232     case 3:
233         data->internal.out = Down_3times;
234         break;
235     
236     default:
237         printf("reach MultiDown Limit!\n");
238         break;
239     }
240     FSM_LOG(" 多击%d ", data->internal.countMultiDown+1);
241 }
242 
243 
244 static State transitionHandler(Downing, Holding)(KeyFSMData* data){
245     data->internal.out = Hold;
246 }
247 
248 static State transitionHandler(MultiDownWaiting, Waiting)(KeyFSMData* data){
249     data->internal.countMultiDown = 0;
250 }
251 
252 
253 
254 /* 
255     用户自定义事件选择逻辑—————————————————begin 
256 */
257 const static char *stateStr[] = {
258     "Idle",
259     "Waiting",
260     "DownDebouncing",
261     "Downing",
262     "Holding",
263     "HoldUpDebouncing",
264     "UpDebouncing",
265     "MultiDownWaiting",
266     "MultiDowning",
267     "MultiDownDebouncing",
268     };
269 
270 static void printFSM(KeyFSM* pFSM){
271     KeyFSMData* data = pFSM->base.data;
272     FSM_LOG("KeyFSM: ");
273     FSM_LOG("%d, 当前状态:%s, \t上一个下次事件:%s \t转移：",  data->internal.countDelay, stateStr[getFSMCurState((FSM *)pFSM)], stateStr[getFSMNextState((FSM *)pFSM)]);
274 }
275 
276 
277 #endif

FSM_OOP/template/templateFSM.c File Reference

重新实现几个必须实现的函数，并赋值到父类指针里 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "FSM_protected.h"
#include "templateFSM.h"
#include "templateFSM_private.h"
Functions
static void loadExternalData (TemplateFSMData *data)
static void resetSignals (FSMSignals *signals, TemplateFSMData *data)
根据条件重置信号 

static void initData (TemplateFSM *pFSM)
给所有内部、外部数据分配堆空间 

static void initDataLoader (TemplateFSM *pFSM)
static void setupHandler (FSMHandler *fcns)
设置状态选择函数、状态内函数和状态转移函数 

static void step (TemplateFSM *pFSM)
重新实现基类的step函数，添加一些打印信息 

TemplateFSM * createTemplateFSM ()
Create a Template FSM object. 

Detailed Description
重新实现几个必须实现的函数，并赋值到父类指针里 

Author
天神 (dalaoshi@stu.xjtu.edu.cn) 
Version
2.1 
Date
2024-05-07
Copyright
天神创意无限公司 2024 

Function Documentation
static void loadExternalData (TemplateFSMData *  data)[static]

Deprecated:
暂时没用，后续考虑data是否需要加锁再说 
Parameters
data 	主要是外部数据 	
static void resetSignals (FSMSignals *  signals, TemplateFSMData *  data)[static]

根据条件重置信号 
清除被响应信号和所有小于被响应信号优先级的信号，具体可以参考notion 
Parameters
signals 	状态机接收到的信号 	
data 	状态机数据 	
static void initData (TemplateFSM *  pFSM)[static]

给所有内部、外部数据分配堆空间 

Parameters
pFSM 		
static void initDataLoader (TemplateFSM *  pFSM)[static]

Deprecated:
弃用 
Parameters
pFSM 		
static void setupHandler (FSMHandler *  fcns)[static]

设置状态选择函数、状态内函数和状态转移函数 

Parameters
fcns 	状态机函数表 	
static void step (TemplateFSM *  pFSM)[static]

重新实现基类的step函数，添加一些打印信息 

Parameters
pFSM 	子类状态机指针 	
TemplateFSM * createTemplateFSM ()

Create a Template FSM object. 
子类状态机细节对外隐藏，外部只能访问基类的公有函数来操作子类变量 
Returns
TemplateFSM* 

FSM_OOP/template/templateFSM.h File Reference

对外暴露接口，外部可以设置状态机的信号 
Data Structures
struct TemplateFSMExternalData自定义外部数据 
struct TemplateFSMInnerData自定义内部数据 
Macros
#define TemplateFSM_Input(pFSM)  ((TemplateFSMExternalData *)_preloadIn((FSM *)pFSM))
Typedefs
typedef struct TemplateFSMExternalData TemplateFSMExternalData
自定义外部数据 

typedef struct TemplateFSMInnerData TemplateFSMInnerData
自定义内部数据 

Enumerations
enum TemplateFSMSignals { Signal_A = 1, Signal_B }
自定义外部信号，目前最多15个 
Functions
TemplateFSM * createTemplateFSM ()
Create a Template FSM object. 

Detailed Description
对外暴露接口，外部可以设置状态机的信号 

Author
天神 (dalaoshi@stu.xjtu.edu.cn) 
Version
2.1 
Date
2024-05-07
Copyright
天神创意无限公司 2024 

Macro Definition Documentation
#define TemplateFSM_Input( pFSM)  ((TemplateFSMExternalData *)_preloadIn((FSM *)pFSM))

Deprecated:
暂时弃用 

Enumeration Type Documentation
enum TemplateFSMSignals

自定义外部信号，目前最多15个 
因为是Unint16存储的信号位 

Enumerator:
Signal_A	必须从1开始，0预留给Idle信号了 

Function Documentation
TemplateFSM * createTemplateFSM ()

Create a Template FSM object. 
子类状态机细节对外隐藏，外部只能访问基类的公有函数来操作子类变量 
Returns
TemplateFSM* 

templateFSM.h
Go to the documentation of this file.
1 
12 #ifndef __TEMPLATE_FSM_H_
13 #define __TEMPLATE_FSM_H_
14 
15 /* -------------------------------------------------------------------------- */
16 /*                               提前做类型声明                               */
17 /* -------------------------------------------------------------------------- */
18 
19 
20 /* -------------------------------------------------------------------------- */
21 /*                               自定义数据和信号                              */
22 /* -------------------------------------------------------------------------- */
28 enum TemplateFSMSignals{
29     Signal_A = 1, 
30     Signal_B,
31 };
32 
37 typedef struct TemplateFSMExternalData
38 {
39     int arrindex;
40     int x;
41 }TemplateFSMExternalData;
42 
43 
48 typedef struct TemplateFSMInnerData
49 {
50     int y1;
51     int inner1;
52 }TemplateFSMInnerData;
53 
54 /* -------------------------------------------------------------------------- */
55 /*                           下面的改个名字就行了                             */
56 /* -------------------------------------------------------------------------- */
57 #define     TemplateFSM_Input(pFSM)          ((TemplateFSMExternalData *)_preloadIn((FSM *)pFSM)) 
59 typedef struct TemplateFSMData
60 {
61     TemplateFSMExternalData external;
62     TemplateFSMInnerData internal;
63 }TemplateFSMData;
64 
65 typedef struct TemplateFSM TemplateFSM;
66 TemplateFSM *createTemplateFSM();
67 
68 
69 #endif

FSM_OOP/template/templateFSM_private.h File Reference

用来声明状态、状态函数等。这个文件只能被templateFSM.c引用一次！ 
#include "FSM_protected.h"
#include "templateFSM.h"
#include <stdio.h>
Macros
#define DEFAULT_STATE  E
Typedefs
typedef enum _State State
状态机内状态定义，Idle和Count_State必须占据开头和结尾两个位置 

Enumerations
enum _State { Idle, D, E, Count_State }
状态机内状态定义，Idle和Count_State必须占据开头和结尾两个位置 

Detailed Description
用来声明状态、状态函数等。这个文件只能被templateFSM.c引用一次！ 

Author
天神 (dalaoshi@stu.xjtu.edu.cn) 
Version
2.1 
Date
2024-05-07
Copyright
天神创意无限公司 2024 

Macro Definition Documentation
#define DEFAULT_STATE  E
默认状态，Idle状态会先跳转到默认状态 

Enumeration Type Documentation
enum _State

状态机内状态定义，Idle和Count_State必须占据开头和结尾两个位置 

Enumerator:
Idle	必须在开头，并且枚举值=0 
	
Count_State	必须在结尾，用来统计状态数量 

templateFSM_private.h
Go to the documentation of this file.
1 
12 #ifdef __TEMPLATE_PRIVATE_FSM_H_
13 #error This file can only be included once!!!
14 
15 #else
16 #define __TEMPLATE_PRIVATE_FSM_H_
17 
18 #include "FSM_protected.h"
19 #include "templateFSM.h"
20 #include <stdio.h>
21 
22 /* -------------------------------------------------------------------------- */
23 /*                            用到的外部变量                                  */
24 /* -------------------------------------------------------------------------- */
25 extern int arrindex;
26 extern int x;
27 
28 
29 /* -------------------------------------------------------------------------- */
30 /*                                继承基类                                    */
31 /* -------------------------------------------------------------------------- */
32 typedef struct TemplateFSM
33 {   
34     FSM base;
35 }TemplateFSM;
36 
37 /* -------------------------------------------------------------------------- */
38 /*                               状态定义                                     */
39 /* -------------------------------------------------------------------------- */
40 
45 typedef enum _State
46 {
47     Idle, 
48     D,
49     E,
50 
51     Count_State, 
52 } State;
53 #define     DEFAULT_STATE       E 
55 /* -------------------------------------------------------------------------- */
56 /*                         下一个状态选择函数                                 */
57 /* -------------------------------------------------------------------------- */
58 
59 
60 static State selectNextStateFcn(D)(TemplateFSMData *data, FSMSignals *signals){
61     if(getSignal(signals, Signal_A)){
62         signals->lastTriggeredSignal = Signal_A;
63         return E;
64     }
65     else if(arrindex == 0){
66         return E;
67     }
68     return Idle;
69 }
70 
71 static State selectNextStateFcn(E)(TemplateFSMData *data, FSMSignals *signals){
72     if(getSignal(signals, Signal_A)){
73         signals->lastTriggeredSignal = Signal_A;
74         return D;
75     }
76     else if(x == 0){
77         return D;
78     }
79     return Idle;
80 }
81 
82 
83 
84 /* -------------------------------------------------------------------------- */
85 /*                    对应的 action, exit, during 函数                        */
86 /* -------------------------------------------------------------------------- */
87 static void actionFcn(enter, D)()
88 {
89     FSM_LOG(" enterD ");
90 }
91 static void actionFcn(during, D)()
92 {
93     FSM_LOG(" duringD ");
94 }
95 static void actionFcn(exit, D)()
96 {
97     FSM_LOG(" exitD ");
98 }
99 
100 static void actionFcn(enter, E)()
101 {
102     FSM_LOG(" enterE ");
103 }
104 static void actionFcn(during, E)()
105 {
106     FSM_LOG(" duringE ");
107 }
108 static void actionFcn(exit, E)()
109 {
110     FSM_LOG(" exitE ");
111 }
112 
113 
114 
115 /* -------------------------------------------------------------------------- */
116 /*                                转移函数                                    */
117 /* -------------------------------------------------------------------------- */
118 static void transitionGeneralAction(FSM pFSM){
119     FSM_LOG("general");
120 }
121 
122 // static void transitionGeneralAction(TemplateFSMData *data){
123 //     FSM_LOG("general");
124 // }
125 
126 static void transitionHandler(Idle, D)()
127 {
128     FSM_LOG(" Idle2D ");
129 }
130 
131 static void transitionHandler(Idle, E)()
132 {
133     FSM_LOG(" Idle2E ");
134 }
135 
136 static void transitionHandler(D, E)(TemplateFSMData *data, int *delayedIndex)
137 {
138     *delayedIndex = index(D, E);
139     FSM_LOG(" D2E ");
140 }
141 
142 static void transitionHandler(E, D)()
143 {
144     FSM_LOG(" E2D ");
145 }
146 
147 
148 /* -------------------------------------------------------------------------- */
149 /*                                打印调试                                    */
150 /* -------------------------------------------------------------------------- */
151 const static char *stateStr[] = {
152     "Idle",
153     "D",
154     "E",
155 };
156 
157 static void printFSM(TemplateFSM* pFSM){
158     FSM_LOG(" \tTemplateFSM: ");
159     FSM_LOG("预装载器溢出:%d, 当前状态:%s, 动作：", _getPreloaderOverFlag((FSM *)pFSM), stateStr[getFSMCurState((FSM *)pFSM)]);
160 }
161 
162 
163 #endif

Index
INDEX