godcreator
/
FSM
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'release/1.1'

This commit is contained in:
godcreator 2024-01-29 22:24:20 +08:00
parent 2c67fede3d c18b289bed
commit 40f3aa6780
10 changed files with 242 additions and 245 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.vscode/settings.json vendored
View File

@ -4,7 +4,8 @@
"fsm_protected.h": "c", "fsm_protected.h": "c",
"keyfsm.h": "c", "keyfsm.h": "c",
"fsm_public.h": "c", "fsm_public.h": "c",
"stdio.h": "c" "stdio.h": "c",
"assert.h": "c"
}, },
"files.encoding": "utf8" "files.encoding": "utf8"
} }

58
FSM_OOP/baseFSM/FSM.c
View File

@ -12,9 +12,9 @@
void resetBaseFSM(FSM *pFSM) void resetBaseFSM(FSM *pFSM)
{ {
if (pFSM->privateVars.fcns.exitActionTable[pFSM->privateVars.curState] != NULL) if (pFSM->privateVars.fcns.exitActionTable[pFSM->privateVars.curState] != NULL)
pFSM->privateVars.fcns.exitActionTable[pFSM->privateVars.curState](pFSM); pFSM->privateVars.fcns.exitActionTable[pFSM->privateVars.curState](pFSM->data);
pFSM->privateVars.curState = 0; pFSM->privateVars.curState = 0;
} }
@ -22,31 +22,44 @@ void resetBaseFSM(FSM *pFSM)
void stepBaseFSM(FSM *pFSM) void stepBaseFSM(FSM *pFSM)
{ {
int index = pFSM->privateVars.curState * pFSM->privateVars.numEvent + pFSM->privateVars.curEvent; int index = pFSM->privateVars.curState * pFSM->privateVars.numEvent + pFSM->privateVars.curEvent;
if (pFSM->privateVars.fcns.transitionTable[index] != NULL) int curState = pFSM->privateVars.curState;
{ int nextState;
if (pFSM->privateVars.fcns.exitActionTable[pFSM->privateVars.curState] != NULL) void *data = pFSM->data;
pFSM->privateVars.fcns.exitActionTable[pFSM->privateVars.curState](pFSM); FSMHandler *fcns = &pFSM->privateVars.fcns;
pFSM->privateVars.curState = (*pFSM->privateVars.fcns.transitionTable[index])(pFSM); if(fcns->delayActionTable[curState] != NULL ){
fcns->delayActionTable[curState](data);
if (pFSM->privateVars.fcns.enterActionTable[pFSM->privateVars.curState] != NULL)
pFSM->privateVars.fcns.enterActionTable[pFSM->privateVars.curState](pFSM);
} }
else if(pFSM->privateVars.curState == 0){
pFSM->privateVars.curState = pFSM->privateVars.defaultState; if (fcns->transitionTable[index] != NULL)
if (pFSM->privateVars.fcns.enterActionTable[pFSM->privateVars.curState] != NULL) {
pFSM->privateVars.fcns.enterActionTable[pFSM->privateVars.curState](pFSM); if (fcns->exitActionTable[curState] != NULL)
fcns->exitActionTable[curState](data);
nextState = (*fcns->transitionTable[index])(data, curState);
if (fcns->enterActionTable[nextState] != NULL)
fcns->enterActionTable[nextState](data);
pFSM->privateVars.curState = nextState;
}
else if(curState == 0){
nextState = pFSM->privateVars.defaultState;
if (fcns->enterActionTable[nextState] != NULL)
fcns->enterActionTable[nextState](data);
pFSM->privateVars.curState = nextState;
} }
else else
{ {
if (pFSM->privateVars.fcns.duringActionTable[pFSM->privateVars.curState] != NULL) if (fcns->duringActionTable[curState] != NULL)
pFSM->privateVars.fcns.duringActionTable[pFSM->privateVars.curState](pFSM); fcns->duringActionTable[curState](data);
} }
} }
FSM* newBaseFSM(int numState, int numEvent, int defaultState){ FSM* newBaseFSM(int numState, int numEvent, int defaultState){
typedef void (*StateFuncPtr)(FSM* pFSM); typedef void (*StateFuncPtr)(void *data);
typedef int (*TransitionFuncPtr)(FSM* pFSM); typedef void (*ChildFSMStepFuncPtr)(FSM **cFSM);
typedef int (*TransitionFuncPtr)(void *data, int currentState);
FSM *pFSM = calloc(1, sizeof(FSM)); FSM *pFSM = calloc(1, sizeof(FSM));
pFSM->privateVars.curEvent = 0; pFSM->privateVars.curEvent = 0;
@ -56,9 +69,12 @@ FSM* newBaseFSM(int numState, int numEvent, int defaultState){
pFSM->privateVars.numChild = 0; pFSM->privateVars.numChild = 0;
pFSM->privateVars.fcns.duringActionTable = calloc(numState, sizeof(StateFuncPtr)); pFSM->privateVars.fcns.duringActionTable = calloc(numState, sizeof(StateFuncPtr));
pFSM->privateVars.fcns.delayActionTable = calloc(numState, sizeof(StateFuncPtr));
pFSM->privateVars.fcns.enterActionTable = calloc(numState, sizeof(StateFuncPtr)); pFSM->privateVars.fcns.enterActionTable = calloc(numState, sizeof(StateFuncPtr));
pFSM->privateVars.fcns.exitActionTable = calloc(numState, sizeof(StateFuncPtr)); pFSM->privateVars.fcns.exitActionTable = calloc(numState, sizeof(StateFuncPtr));
pFSM->privateVars.fcns.transitionTable = calloc(numState * numEvent, sizeof(TransitionFuncPtr)); pFSM->privateVars.fcns.transitionTable = calloc(numState * numEvent, sizeof(TransitionFuncPtr));
pFSM->privateVars.fcns.childFSMStepTable = calloc(numState * numEvent, sizeof(ChildFSMStepFuncPtr));
FSMVtbl vtbl = { FSMVtbl vtbl = {
.reset = resetBaseFSM, .reset = resetBaseFSM,
@ -96,9 +112,11 @@ int getFSMCurEvent(FSM *pFSM){
void setEvent(FSM* pFSM){ void setEvent(FSM* pFSM){
assert(pFSM->vtbl.selectEvent); assert(pFSM->vtbl.selectEvent);
pFSM->privateVars.curEvent = pFSM->vtbl.selectEvent(pFSM->data);
int e = pFSM->vtbl.selectEvent(pFSM->data); if(0 == pFSM->privateVars.numChild){
pFSM->privateVars.curEvent = e; return;
}
for (int i = 0; i < pFSM->privateVars.numChild; i++) for (int i = 0; i < pFSM->privateVars.numChild; i++)
{ {

49
FSM_OOP/baseFSM/FSM_protected.h
View File

@ -3,37 +3,59 @@
#include "FSM_public.h" #include "FSM_public.h"
#define during #ifdef DSP28377
#define enter #define NDEBUG
#define exit #else
#define FSM_LOG_ON
#endif
#ifdef FSM_LOG_ON
#define FSM_LOG(...) printf(__VA_ARGS__)
#else
#define FSM_LOG(...) ((void)0)
#endif
#define delay delay
#define during during
#define enter enter
#define exit exit
#define transitionHandler(event) event##Handler #define transitionHandler(event) event##Handler
#define actionFcn(action, state) state##_##action##Action #define actionFcn(action, state) state##_##action##Action
#define index(state, event) (state*Count_Event + event) #define index(state, event) (state*Count_Event + event)
typedef struct _FSMHandler FSMHandler; typedef struct _FSMHandler FSMHandler;
typedef void (*Avoid_WARNING_void_FSM)(FSM *pFSM); typedef void (*Avoid_WARNING_State_Fcns)(void *data);
typedef int (*Avoid_WARNING_int_FSM)(FSM *pFSM); typedef int (*Avoid_WARNING_Transition_Handler)(void *data, int curState);
typedef int (*Avoid_WARNING_int_data)(void *data); typedef void (*Avoid_WARNING_Overrider_Fcns)(FSM *pFsm);
typedef int (*Avoid_WARNING_SelectEvent)(void *data);
typedef void (*Avoid_WARNING_void_fcns)(FSMHandler *fcns); typedef void (*Avoid_WARNING_void_fcns)(FSMHandler *fcns);
#define addStateActionFcn(type, state) fcns->type##ActionTable[state] = (Avoid_WARNING_State_Fcns)actionFcn(type, state)
#define addTransitionHandler(state, event) fcns->transitionTable[index(state, event)] = (Avoid_WARNING_Transition_Handler)transitionHandler(event)
typedef struct _FSM FSM; typedef struct _FSM FSM;
typedef struct _FSMHandler{ typedef struct _FSMHandler{
int (**transitionTable)(FSM *pFSM); int (**transitionTable)(void *data, int currentState);
void (**enterActionTable)(FSM *pFSM);
void (**duringActionTable)(FSM *pFSM); void (**enterActionTable)(void *data);
void (**exitActionTable)(FSM *pFSM); void (**delayActionTable)(void *data);
void (**duringActionTable)(void *data);
void (**exitActionTable)(void *data);
void (**childFSMStepTable)(FSM **cFSM);
}FSMHandler; }FSMHandler;
typedef struct _FSMPrivateVars typedef struct _FSMPrivateVars
{ {
int curState; int curState;
int defaultState; // Idle状态不能停留，必须指定一个初始状态
int curEvent; int curEvent;
int defaultState; // Idle状态不能停留，必须指定一个初始状态
int numEvent; int numEvent;
int numChild; int numChild;
FSM **childFSM; FSM **childFSM;
@ -51,14 +73,13 @@ typedef struct _FSM
FMSPrivateVars privateVars; FMSPrivateVars privateVars;
// protected // protected
void *data; void *data;
} FSM; } FSM;
// protected, 子类能用, 外界用不了 // protected, 子类能用, 外界用不了
int getFSMCurState(FSM *pFSM);
int getFSMCurEvent(FSM *pFSM);
void constructFSM(FSM* pFSM); void constructFSM(FSM* pFSM);
// 继承的函数 // 继承的函数

11
FSM_OOP/baseFSM/FSM_public.h
View File

@ -1,13 +1,15 @@
#ifndef __FSM_PUBLIC_H_ #ifndef __FSM_PUBLIC_H_
#define __FSM_PUBLIC_H_ #define __FSM_PUBLIC_H_
// #define BASE_FSM(ptr) ((FSM *)(ptr))
#define BASE_FSM(ptr) ((FSM *)(ptr)) // #define BASE_PTR (FSM *)
#define BASE_PTR (FSM *)
typedef struct _FSM FSM; typedef struct _FSM FSM;
typedef FSM * FSM_Ptr; typedef FSM * FSM_Ptr;
#define SetEvent(FSM) setEvent((FSM_Ptr)FSM)
#define Step(FSM) vptrFSM((FSM_Ptr)FSM)->step((FSM_Ptr)FSM)
typedef struct _FSMHandler FSMHandler; typedef struct _FSMHandler FSMHandler;
// 这几个函数可认为是虚函数, 构造函数里不会初始化FSMVtbl, 必须由子类重新实现 // 这几个函数可认为是虚函数, 构造函数里不会初始化FSMVtbl, 必须由子类重新实现
typedef struct _FSMVtbl { typedef struct _FSMVtbl {
@ -20,7 +22,8 @@ typedef struct _FSMVtbl {
}FSMVtbl; }FSMVtbl;
int getFSMCurState(FSM *pFSM);
int getFSMCurEvent(FSM *pFSM);
void setEvent(FSM* pFSM); void setEvent(FSM* pFSM);
void setChildNum(FSM *pFSM, int num); void setChildNum(FSM *pFSM, int num);
void registerChildFSM(FSM *parent, FSM *child, int index); void registerChildFSM(FSM *parent, FSM *child, int index);

24
FSM_OOP/template/templateFSM.c
View File

@ -40,19 +40,19 @@ static void initData(TemplateFSM *pFSM){ // 必须重新实现
} }
static void setupHandler(FSMHandler* fcns){ // 必须重新实现 static void setupHandler(FSMHandler* fcns){ // 必须重新实现
fcns->duringActionTable[E] = (Avoid_WARNING_void_FSM)actionFcn(during, E); fcns->duringActionTable[E] = (Avoid_WARNING_State_Fcns)actionFcn(during, E);
fcns->duringActionTable[D] = (Avoid_WARNING_void_FSM)actionFcn(during, D); fcns->duringActionTable[D] = (Avoid_WARNING_State_Fcns)actionFcn(during, D);
fcns->enterActionTable[D] = (Avoid_WARNING_void_FSM)actionFcn(enter, D); fcns->enterActionTable[D] = (Avoid_WARNING_State_Fcns)actionFcn(enter, D);
fcns->enterActionTable[E] = (Avoid_WARNING_void_FSM)actionFcn(enter, E); fcns->enterActionTable[E] = (Avoid_WARNING_State_Fcns)actionFcn(enter, E);
fcns->exitActionTable[D] = (Avoid_WARNING_void_FSM)D_exitAction; fcns->exitActionTable[D] = (Avoid_WARNING_State_Fcns)D_exitAction;
fcns->exitActionTable[E] = (Avoid_WARNING_void_FSM)E_exitAction; fcns->exitActionTable[E] = (Avoid_WARNING_State_Fcns)E_exitAction;
fcns->transitionTable[index(Idle, Idle2D)] = (Avoid_WARNING_int_FSM)transitionHandler(Idle2D); fcns->transitionTable[index(Idle, Idle2D)] = (Avoid_WARNING_Transition_Handler)transitionHandler(Idle2D);
fcns->transitionTable[index(Idle, Idle2E)] = (Avoid_WARNING_int_FSM)transitionHandler(Idle2E); fcns->transitionTable[index(Idle, Idle2E)] = (Avoid_WARNING_Transition_Handler)transitionHandler(Idle2E);
fcns->transitionTable[index(D, D2E)] = (Avoid_WARNING_int_FSM)transitionHandler(D2E); fcns->transitionTable[index(D, D2E)] = (Avoid_WARNING_Transition_Handler)transitionHandler(D2E);
fcns->transitionTable[index(E, E2D)] = (Avoid_WARNING_int_FSM)transitionHandler(E2D); fcns->transitionTable[index(E, E2D)] = (Avoid_WARNING_Transition_Handler)transitionHandler(E2D);
} }
/* /*
@ -64,9 +64,9 @@ TemplateFSM *createTemplateFSM(){
TemplateFSM *pFSM; TemplateFSM *pFSM;
pFSM = (TemplateFSM *)newBaseFSM(Count_State, Count_Event, DEFAULT_STATE); pFSM = (TemplateFSM *)newBaseFSM(Count_State, Count_Event, DEFAULT_STATE);
pFSM->base.vtbl.step = (Avoid_WARNING_void_FSM)step; pFSM->base.vtbl.step = (Avoid_WARNING_State_Fcns)step;
pFSM->base.vtbl.selectEvent = (Avoid_WARNING_int_data)selectEvent; pFSM->base.vtbl.selectEvent = (Avoid_WARNING_int_data)selectEvent;
pFSM->base.vtbl.initData = (Avoid_WARNING_void_FSM)initData; pFSM->base.vtbl.initData = (Avoid_WARNING_State_Fcns)initData;
pFSM->base.vtbl.setupHandler = (Avoid_WARNING_void_fcns)setupHandler; pFSM->base.vtbl.setupHandler = (Avoid_WARNING_void_fcns)setupHandler;
constructFSM((FSM_Ptr)pFSM); constructFSM((FSM_Ptr)pFSM);

98
FSM_OOP/usr/keyFSM.c
View File

@ -10,38 +10,28 @@
*/ */
static Event selectEvent(KeyFSMData *data){ // 必须重新实现 static Event selectEvent(KeyFSMData *data){ // 必须重新实现
if(data->countDelay == 4){
if(data->countDelay == 10){
return HoldCount4; return HoldCount4;
} }
else if(data->countDelay == 5){
if(data->countDelay == 3){
if(data->countMultiDown && data->lastState == MultiDownWaiting){
return MultiDown;
}
if(data->lastState == Holding){
return UpDebouncing2Waiting;
}
return DelayCount3; return DelayCount3;
} }
else if(data->in == Up){
if(data->in == Up){
return PhsicalUp; return PhsicalUp;
} }
else{ else{
if(data->lastState == Holding){
return UpDebouncing2Holding;
}
return PhsicalDown; return PhsicalDown;
} }
} }
static void step(KeyFSM* pFSM){ static void step(KeyFSM* pFSM){
printFSM(pFSM); printFSM(pFSM);
stepBaseFSM(BASE_FSM(pFSM)); stepBaseFSM((FSM_Ptr)pFSM);
KeyFSMData * data = pFSM->base.data; KeyFSMData * data = pFSM->base.data;
printf("\t信号:%d, 计数%d, 上次状态%s", data->out, data->countDelay, stateStr[data->lastState]); FSM_LOG("\t信号:%d, 计数%d ", data->out, data->countDelay);
} }
static void initData(KeyFSM *pFSM){ // 必须重新实现 static void initData(KeyFSM *pFSM){ // 必须重新实现
@ -50,54 +40,39 @@ static void initData(KeyFSM *pFSM){ // 必须重新实现
data->countMultiDown = 0; data->countMultiDown = 0;
data->in = Up; data->in = Up;
data->out = Idle; data->out = Idle;
data->lastState = 0;
pFSM->base.data = data; pFSM->base.data = data;
} }
static void setupHandler(FSMHandler* fcns){ // 必须重新实现 static void setupHandler(FSMHandler* fcns){ // 必须重新实现
fcns->duringActionTable[Waiting] = (Avoid_WARNING_void_FSM)actionFcn(during, Waiting); addStateActionFcn(enter, Waiting);
fcns->exitActionTable[Waiting] = (Avoid_WARNING_void_FSM)actionFcn(exit, Waiting); addStateActionFcn(during, DownDebouncing);
addStateActionFcn(during, Downing);
fcns->duringActionTable[DownDebouncing] = (Avoid_WARNING_void_FSM)actionFcn(during, DownDebouncing); addStateActionFcn(delay, Downing);
fcns->exitActionTable[DownDebouncing] = (Avoid_WARNING_void_FSM)actionFcn(exit, DownDebouncing); addStateActionFcn(during, UpDebouncing);
addStateActionFcn(during, Holding);
fcns->duringActionTable[Downing] = (Avoid_WARNING_void_FSM)actionFcn(during, Downing); addStateActionFcn(exit, Holding);
fcns->exitActionTable[Downing] = (Avoid_WARNING_void_FSM)actionFcn(exit, Downing); addStateActionFcn(during, MultiDownWaiting);
addStateActionFcn(delay, MultiDowning);
fcns->duringActionTable[UpDebouncing] = (Avoid_WARNING_void_FSM)actionFcn(during, UpDebouncing); addStateActionFcn(during, HoldUpDebouncing);
fcns->exitActionTable[UpDebouncing] = (Avoid_WARNING_void_FSM)actionFcn(exit, UpDebouncing); addStateActionFcn(during, MultiDownDebouncing);
fcns->duringActionTable[Holding] = (Avoid_WARNING_void_FSM)actionFcn(during, Holding);
fcns->exitActionTable[Holding] = (Avoid_WARNING_void_FSM)actionFcn(exit, Holding);
fcns->duringActionTable[MultiDownWaiting] = (Avoid_WARNING_void_FSM)actionFcn(during, MultiDownWaiting);
fcns->duringActionTable[MultiDowning] = (Avoid_WARNING_void_FSM)actionFcn(during, MultiDowning);
fcns->exitActionTable[MultiDowning] = (Avoid_WARNING_void_FSM)actionFcn(during, MultiDowning);
fcns->transitionTable[index(Waiting, PhsicalDown)] = (Avoid_WARNING_int_FSM)transitionHandler(PhsicalDown); addTransitionHandler(Waiting, PhsicalDown);
addTransitionHandler(DownDebouncing, PhsicalUp);
fcns->transitionTable[index(DownDebouncing, PhsicalUp)] = (Avoid_WARNING_int_FSM)transitionHandler(PhsicalUp); addTransitionHandler(DownDebouncing, DelayCount3);
fcns->transitionTable[index(DownDebouncing, DelayCount3)] = (Avoid_WARNING_int_FSM)transitionHandler(DelayCount3); addTransitionHandler(Downing, PhsicalUp);
fcns->transitionTable[index(DownDebouncing, MultiDown)] = (Avoid_WARNING_int_FSM)transitionHandler(MultiDown); addTransitionHandler(Downing, HoldCount4);
addTransitionHandler(UpDebouncing, PhsicalDown);
fcns->transitionTable[index(Downing, PhsicalUp)] = (Avoid_WARNING_int_FSM)transitionHandler(PhsicalUp); addTransitionHandler(UpDebouncing, DelayCount3);
fcns->transitionTable[index(Downing, HoldCount4)] = (Avoid_WARNING_int_FSM)transitionHandler(HoldCount4); addTransitionHandler(Holding, PhsicalUp);
addTransitionHandler(MultiDownWaiting, PhsicalDown);
fcns->transitionTable[index(UpDebouncing, PhsicalDown)] = (Avoid_WARNING_int_FSM)transitionHandler(PhsicalDown); addTransitionHandler(MultiDownWaiting, DelayCount3);
fcns->transitionTable[index(UpDebouncing, DelayCount3)] = (Avoid_WARNING_int_FSM)transitionHandler(DelayCount3); addTransitionHandler(MultiDowning, PhsicalUp);
fcns->transitionTable[index(UpDebouncing, UpDebouncing2Holding)] = (Avoid_WARNING_int_FSM)transitionHandler(UpDebouncing2Holding); addTransitionHandler(HoldUpDebouncing, PhsicalDown);
fcns->transitionTable[index(UpDebouncing, UpDebouncing2Waiting)] = (Avoid_WARNING_int_FSM)transitionHandler(UpDebouncing2Waiting); addTransitionHandler(HoldUpDebouncing, DelayCount3);
addTransitionHandler(MultiDownDebouncing, DelayCount3);
fcns->transitionTable[index(Holding, PhsicalUp)] = (Avoid_WARNING_int_FSM)transitionHandler(PhsicalUp); addTransitionHandler(MultiDownDebouncing, PhsicalUp);
fcns->transitionTable[index(MultiDownWaiting, PhsicalDown)] = (Avoid_WARNING_int_FSM)transitionHandler(PhsicalDown);
fcns->transitionTable[index(MultiDownWaiting, DelayCount3)] = (Avoid_WARNING_int_FSM)transitionHandler(DelayCount3);
fcns->transitionTable[index(MultiDowning, PhsicalUp)] = (Avoid_WARNING_int_FSM)transitionHandler(PhsicalUp);
} }
/* /*
@ -109,9 +84,12 @@ KeyFSM *createKeyFSM(){
KeyFSM *pFSM; KeyFSM *pFSM;
pFSM = (KeyFSM *)newBaseFSM(Count_State, Count_Event, DEFAULT_STATE); pFSM = (KeyFSM *)newBaseFSM(Count_State, Count_Event, DEFAULT_STATE);
pFSM->base.vtbl.step = (Avoid_WARNING_void_FSM)step; #ifndef DSP28377
pFSM->base.vtbl.selectEvent = (Avoid_WARNING_int_data)selectEvent; pFSM->base.vtbl.step = (Avoid_WARNING_Overrider_Fcns)step;
pFSM->base.vtbl.initData = (Avoid_WARNING_void_FSM)initData; #endif
pFSM->base.vtbl.selectEvent = (Avoid_WARNING_SelectEvent)selectEvent;
pFSM->base.vtbl.initData = (Avoid_WARNING_Overrider_Fcns)initData;
pFSM->base.vtbl.setupHandler = (Avoid_WARNING_void_fcns)setupHandler; pFSM->base.vtbl.setupHandler = (Avoid_WARNING_void_fcns)setupHandler;
constructFSM((FSM_Ptr)pFSM); constructFSM((FSM_Ptr)pFSM);

12
FSM_OOP/usr/keyFSM.h
View File

@ -2,6 +2,8 @@
#define __KEY_FSM_H_ #define __KEY_FSM_H_
typedef enum _keyIn{ typedef enum _keyIn{
Up, Up,
pDown, pDown,
@ -16,13 +18,21 @@ typedef enum _keyOutSignal{
Down_3times, Down_3times,
}KeyOutSignal; }KeyOutSignal;
const static char *keyStr[] =
{
"Idle",
"Down",
"Hold",
"Down_2times",
"Down_3times",
};
typedef struct _keyFSMData typedef struct _keyFSMData
{ {
int countDelay; int countDelay;
int countMultiDown; int countMultiDown;
KeyIn in; KeyIn in;
KeyOutSignal out; KeyOutSignal out;
int lastState;
}KeyFSMData; }KeyFSMData;
typedef struct _KeyFSM KeyFSM; typedef struct _KeyFSM KeyFSM;

217
FSM_OOP/usr/keyFSM_private.h
View File

@ -29,102 +29,89 @@ typedef enum _State
UpDebouncing, UpDebouncing,
MultiDownWaiting, MultiDownWaiting,
MultiDowning, MultiDowning,
HoldUpDebouncing,
MultiDownDebouncing,
Count_State, Count_State,
} State; } State;
#define DEFAULT_STATE Waiting #define DEFAULT_STATE Waiting
static void actionFcn(during, Waiting)(KeyFSM *pFSM){ static void actionFcn(enter, Waiting)(KeyFSMData* data){
KeyFSMData * data = pFSM->base.data;
data->out = Idle;
}
static void actionFcn(exit, Waiting)(KeyFSM *pFSM){
KeyFSMData * data = pFSM->base.data;
data->out = Idle; data->out = Idle;
data->countDelay = 0;
data->countMultiDown = 0;
} }
static void actionFcn(during, DownDebouncing)(KeyFSMData* data)
static void actionFcn(during, DownDebouncing)(KeyFSM *pFSM)
{ {
KeyFSMData * data = pFSM->base.data;
data->countDelay++; data->countDelay++;
printf(" during开启消抖 "); FSM_LOG(" during开启消抖 ");
} }
static void actionFcn(exit, DownDebouncing)(KeyFSM *pFSM){ static void actionFcn(delay, Downing)(KeyFSMData* data)
KeyFSMData * data = pFSM->base.data;
data->lastState = Idle_State;
}
static void actionFcn(during, Downing)(KeyFSM *pFSM)
{ {
KeyFSMData * data = pFSM->base.data; data->out = Idle;
}
static void actionFcn(during, Downing)(KeyFSMData* data)
{
data->countDelay++; data->countDelay++;
data->out = Idle; data->out = Idle;
} }
static void actionFcn(exit, Downing)(KeyFSM *pFSM)
{
KeyFSMData * data = pFSM->base.data;
data->out = Idle;
}
static void actionFcn(during, UpDebouncing)(KeyFSM *pFSM){ static void actionFcn(during, UpDebouncing)(KeyFSMData* data){
KeyFSMData * data = pFSM->base.data;
data->countDelay++; data->countDelay++;
printf(" during松开消抖 "); FSM_LOG(" during松开消抖 ");
}
static void actionFcn(exit, UpDebouncing)(KeyFSM *pFSM){
KeyFSMData * data = pFSM->base.data;
data->lastState = Idle_State;
} }
static void actionFcn(during, Holding)(KeyFSMData* data){
data->out = Idle;
static void actionFcn(during, Holding)(KeyFSM *pFSM){
KeyFSMData * data = pFSM->base.data;
data->countDelay++; data->countDelay++;
if(data->countDelay == 2){ if(data->countDelay == 2){
data->out = Hold; data->out = Hold;
data->countDelay = 0; data->countDelay = 0;
} }
else{
data->out = Idle;
}
} }
static void actionFcn(exit, Holding)(KeyFSM *pFSM){ static void actionFcn(exit, Holding)(KeyFSMData* data){
KeyFSMData * data = pFSM->base.data;
data->out = Idle; data->out = Idle;
} }
static void actionFcn(during, MultiDownWaiting)(KeyFSM *pFSM){ static void actionFcn(during, MultiDownWaiting)(KeyFSMData* data){
KeyFSMData * data = pFSM->base.data;
data->countDelay++; data->countDelay++;
printf(" during多击等待 "); FSM_LOG(" during多击等待 ");
} }
static void actionFcn(during, MultiDowning)(KeyFSM *pFSM) static void actionFcn(delay, MultiDowning)(KeyFSMData* data)
{ {
KeyFSMData * data = pFSM->base.data;
data->out = Idle; data->out = Idle;
} }
static void actionFcn(exit, MultiDowning)(KeyFSM *pFSM){
KeyFSMData * data = pFSM->base.data; static void actionFcn(during, HoldUpDebouncing)(KeyFSMData* data)
data->out = Idle; {
data->countDelay++;
} }
static void actionFcn(during, MultiDownDebouncing)(KeyFSMData* data)
{
data->countDelay++;
}
/* /*
事件和对应的转移函数 事件和对应的转移函数
@ -135,54 +122,47 @@ typedef enum _Event{
PhsicalDown, PhsicalDown,
PhsicalUp, PhsicalUp,
DelayCount3, DelayCount3,
HoldCount4, HoldCount4,
MultiDown,
UpDebouncing2Holding,
UpDebouncing2Waiting,
Count_Event, Count_Event,
}Event; }Event;
static State transitionHandler(PhsicalDown)(KeyFSM *pFSM) static State transitionHandler(PhsicalDown)(KeyFSMData* data, State curState)
{ {
printf(" 物理按键按下 "); FSM_LOG(" 物理按键按下 ");
KeyFSMData * data = pFSM->base.data;
data->countDelay = 0; data->countDelay = 0;
switch (getFSMCurState((FSM_Ptr)pFSM))
switch (curState)
{ {
case Waiting: case Waiting:
return DownDebouncing; return DownDebouncing;
case UpDebouncing: case UpDebouncing:
if(data->countMultiDown){ if(data->countMultiDown)
return MultiDowning; return MultiDowning;
}
if(data->lastState == Holding){
data->lastState = Idle_State;
return Holding;
}
else else
return Downing; return Downing;
case HoldUpDebouncing:
return Holding;
case MultiDownWaiting: case MultiDownWaiting:
data->lastState = MultiDownWaiting; return MultiDownDebouncing;
return DownDebouncing;
default: default:
printf("检查状态转移表设计，不应该到这里"); FSM_LOG("检查状态转移表设计，不应该到这里");
assert(0); assert(0);
} }
} }
static State transitionHandler(PhsicalUp)(KeyFSM *pFSM) static State transitionHandler(PhsicalUp)(KeyFSMData* data, State curState)
{ {
printf(" 物理按键松开 "); FSM_LOG(" 物理按键松开 ");
KeyFSMData * data = pFSM->base.data;
data->countDelay = 0; data->countDelay = 0;
switch (getFSMCurState((FSM_Ptr)pFSM))
switch (curState)
{ {
case DownDebouncing: case DownDebouncing:
if(data->countMultiDown){ if(data->countMultiDown){
@ -193,99 +173,76 @@ static State transitionHandler(PhsicalUp)(KeyFSM *pFSM)
case Downing: case Downing:
return UpDebouncing; return UpDebouncing;
case Holding: case Holding:
data->lastState = Holding; return HoldUpDebouncing;
return UpDebouncing;
case MultiDowning: case MultiDowning:
return UpDebouncing; return UpDebouncing;
default: default:
printf("检查状态转移表设计，不应该到这里"); FSM_LOG("检查状态转移表设计，不应该到这里");
assert(0); assert(0);
} }
} }
static State transitionHandler(DelayCount3)(KeyFSM *pFSM){ static State transitionHandler(DelayCount3)(KeyFSMData* data, State curState){
printf(" 延迟计数到3 "); FSM_LOG(" 延迟计数到3 ");
KeyFSMData * data = pFSM->base.data;
data->countDelay = 0; data->countDelay = 0;
switch (getFSMCurState((FSM_Ptr)pFSM))
switch (curState)
{ {
case DownDebouncing: case DownDebouncing:
data->out = Down; data->out = Down;
FSM_LOG("按键按下");
printf("按键按下");
return Downing; return Downing;
case UpDebouncing: case UpDebouncing:
data->out = Up; data->out = Up;
data->countMultiDown++; data->countMultiDown++;
printf("按键松开"); FSM_LOG("按键松开");
return MultiDownWaiting; return MultiDownWaiting;
case MultiDownWaiting: case MultiDownWaiting:
data->out = Idle;
data->countMultiDown = 0;
return Waiting; return Waiting;
case HoldUpDebouncing:
return Waiting;
case MultiDownDebouncing:
switch (data->countMultiDown + 1)
{
case 2:
data->out = Down_2times;
break;
case 3:
data->out = Down_3times;
break;
default:
printf("reach MultiDown Limit!\n");
break;
}
FSM_LOG(" 多击%d ", data->countMultiDown+1);
return MultiDowning;
default: default:
printf("检查状态转移表设计，不应该到这里"); FSM_LOG("检查状态转移表设计，不应该到这里");
assert(0); assert(0);
} }
} }
static State transitionHandler(HoldCount4)(KeyFSM *pFSM){ static State transitionHandler(HoldCount4)(KeyFSMData* data, State curState){
printf(" 计数到2进入长按模式 "); FSM_LOG(" 计数到2进入长按模式 ");
KeyFSMData * data = pFSM->base.data;
data->countDelay = 0; data->countDelay = 0;
data->out = Hold; data->out = Hold;
return Holding; return Holding;
} }
static State transitionHandler(MultiDown)(KeyFSM *pFSM){
printf(" 多击 ");
KeyFSMData * data = pFSM->base.data;
data->countDelay = 0;
switch (data->countMultiDown + 1)
{
case 2:
data->out = Down_2times;
break;
case 3:
data->out = Down_3times;
break;
default:
printf(" 到达多击次数上限了 ");
break;
}
printf(" 多击%d ", data->countMultiDown+1);
return MultiDowning;
}
static State transitionHandler(UpDebouncing2Holding)(KeyFSM *pFSM){
printf(" 回到长按 ");
KeyFSMData * data = pFSM->base.data;
data->countDelay = 0;
data->out = Idle;
return Holding;
}
static State transitionHandler(UpDebouncing2Waiting)(KeyFSM *pFSM){
printf(" 关闭消抖到等待 ");
KeyFSMData * data = pFSM->base.data;
data->countDelay = 0;
data->out = Idle;
return Waiting;
}
/* /*
用户自定义事件选择逻辑—————————————————begin 用户自定义事件选择逻辑—————————————————begin
@ -299,6 +256,8 @@ const static char *stateStr[] = {
"UpDebouncing", "UpDebouncing",
"MultiDownWaiting", "MultiDownWaiting",
"MultiDowning", "MultiDowning",
"HoldUpDebouncing",
"MultiDownDebouncing",
}; };
const static char *eventStr[] = { const static char *eventStr[] = {
"Idle", "Idle",
@ -306,13 +265,11 @@ const static char *eventStr[] = {
"PhsicalUp", "PhsicalUp",
"DelayCount3", "DelayCount3",
"HoldCount4", "HoldCount4",
"MultiDown",
"UpDebouncing2Holding",
"UpDebouncing2Waiting"
}; };
static void printFSM(KeyFSM* pFSM){ static void printFSM(KeyFSM* pFSM){
printf("\tKeyFSM: "); KeyFSMData* data = pFSM->base.data;
printf("当前状态:%s, \t\t当前事件:%s, \t\t转移：", stateStr[getFSMCurState((FSM_Ptr)pFSM)], eventStr[getFSMCurEvent((FSM_Ptr)pFSM)]); FSM_LOG("KeyFSM: ");
FSM_LOG("%d, 当前状态:%s, \t当前事件:%s \t转移：", data->countDelay, stateStr[getFSMCurState((FSM_Ptr)pFSM)], eventStr[getFSMCurEvent((FSM_Ptr)pFSM)]);
} }

15
main.c
View File

@ -19,6 +19,12 @@ KeyIn testin[NUM] = {
pDown,pDown,pDown,pDown pDown,pDown,pDown,pDown
}; };
typedef void (*fcn)();
void printtest(){
printf("fcn\n");
}
int main(){ int main(){
@ -29,8 +35,9 @@ int main(){
printf("第%d次: ",i+1); printf("第%d次: ",i+1);
KeyFSMData* data = getData((FSM_Ptr)keyFSM); KeyFSMData* data = getData((FSM_Ptr)keyFSM);
data->in = testin[i]; data->in = testin[i];
setEvent((FSM_Ptr)keyFSM);
vptrFSM((FSM_Ptr)keyFSM)->step((FSM_Ptr)keyFSM); SetEvent(keyFSM);
Step(keyFSM);
if(data->out){ if(data->out){
printf("\t\t\t\t%d", data->out); printf("\t\t\t\t%d", data->out);
@ -41,7 +48,9 @@ int main(){
} }
printf("hello world, 你好世界"); printf("hello world, 你好世界\n");
fcn fcnptr = printtest;
(fcnptr == NULL) ? : fcnptr();
return 0; return 0;
} }

BIN
状态图.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 140 KiB

After

Width:  |  Height:  |  Size: 1.4 MiB