diff --git a/.vscode/settings.json b/.vscode/settings.json
index 47a014f..6a6f9c2 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -4,7 +4,8 @@
         "fsm_protected.h": "c",
         "keyfsm.h": "c",
         "fsm_public.h": "c",
-        "stdio.h": "c"
+        "stdio.h": "c",
+        "assert.h": "c"
     },
     "files.encoding": "utf8"
 }
\ No newline at end of file
diff --git a/FSM_OOP/baseFSM/FSM.c b/FSM_OOP/baseFSM/FSM.c
index 1438273..4489006 100644
--- a/FSM_OOP/baseFSM/FSM.c
+++ b/FSM_OOP/baseFSM/FSM.c
@@ -12,9 +12,9 @@
 
 void resetBaseFSM(FSM *pFSM)
 {
-    
+   
     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;
 }
@@ -22,31 +22,44 @@ void resetBaseFSM(FSM *pFSM)
 void stepBaseFSM(FSM *pFSM)
 {
     int index = pFSM->privateVars.curState * pFSM->privateVars.numEvent + pFSM->privateVars.curEvent;
-    if (pFSM->privateVars.fcns.transitionTable[index] != NULL)
-    {
-        if (pFSM->privateVars.fcns.exitActionTable[pFSM->privateVars.curState] != NULL)
-            pFSM->privateVars.fcns.exitActionTable[pFSM->privateVars.curState](pFSM);
+    int curState = pFSM->privateVars.curState;
+    int nextState;
+    void *data = pFSM->data;
+    FSMHandler *fcns = &pFSM->privateVars.fcns;
 
-        pFSM->privateVars.curState = (*pFSM->privateVars.fcns.transitionTable[index])(pFSM);
-
-        if (pFSM->privateVars.fcns.enterActionTable[pFSM->privateVars.curState] != NULL)
-            pFSM->privateVars.fcns.enterActionTable[pFSM->privateVars.curState](pFSM);
+    if(fcns->delayActionTable[curState] != NULL ){
+        fcns->delayActionTable[curState](data);
     }
-    else if(pFSM->privateVars.curState == 0){
-        pFSM->privateVars.curState = pFSM->privateVars.defaultState;
-        if (pFSM->privateVars.fcns.enterActionTable[pFSM->privateVars.curState] != NULL)
-            pFSM->privateVars.fcns.enterActionTable[pFSM->privateVars.curState](pFSM);
+
+    if (fcns->transitionTable[index] != NULL)
+    {
+        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
     {
-        if (pFSM->privateVars.fcns.duringActionTable[pFSM->privateVars.curState] != NULL)
-            pFSM->privateVars.fcns.duringActionTable[pFSM->privateVars.curState](pFSM);
+        if (fcns->duringActionTable[curState] != NULL)
+            fcns->duringActionTable[curState](data);
     }
 }
 
 FSM*  newBaseFSM(int numState, int numEvent, int defaultState){
-    typedef void (*StateFuncPtr)(FSM* pFSM);
-    typedef int (*TransitionFuncPtr)(FSM* pFSM);
+    typedef void (*StateFuncPtr)(void *data); 
+    typedef void (*ChildFSMStepFuncPtr)(FSM **cFSM); 
+    typedef int (*TransitionFuncPtr)(void *data, int currentState);
 
     FSM *pFSM = calloc(1, sizeof(FSM));
     pFSM->privateVars.curEvent = 0;
@@ -56,9 +69,12 @@ FSM*  newBaseFSM(int numState, int numEvent, int defaultState){
     pFSM->privateVars.numChild = 0;
 
     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.exitActionTable = calloc(numState, sizeof(StateFuncPtr));
+    
     pFSM->privateVars.fcns.transitionTable = calloc(numState * numEvent, sizeof(TransitionFuncPtr));
+    pFSM->privateVars.fcns.childFSMStepTable = calloc(numState * numEvent, sizeof(ChildFSMStepFuncPtr));
 
     FSMVtbl vtbl = {
         .reset = resetBaseFSM,
@@ -96,9 +112,11 @@ int getFSMCurEvent(FSM *pFSM){
 
 void setEvent(FSM* pFSM){
     assert(pFSM->vtbl.selectEvent);
+    pFSM->privateVars.curEvent = pFSM->vtbl.selectEvent(pFSM->data);
 
-    int e = pFSM->vtbl.selectEvent(pFSM->data);
-    pFSM->privateVars.curEvent = e;
+    if(0 == pFSM->privateVars.numChild){
+        return;
+    }
 
     for (int i = 0; i < pFSM->privateVars.numChild; i++)
     {
diff --git a/FSM_OOP/baseFSM/FSM_protected.h b/FSM_OOP/baseFSM/FSM_protected.h
index 6bc72f8..9a0c155 100644
--- a/FSM_OOP/baseFSM/FSM_protected.h
+++ b/FSM_OOP/baseFSM/FSM_protected.h
@@ -3,37 +3,59 @@
 
 #include "FSM_public.h"
 
-#define     during
-#define     enter
-#define     exit
+#ifdef      DSP28377
+    #define     NDEBUG
+#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     actionFcn(action, state)            state##_##action##Action
 #define     index(state, event)     (state*Count_Event + event)
 
 typedef struct _FSMHandler FSMHandler;
-typedef void (*Avoid_WARNING_void_FSM)(FSM *pFSM);
-typedef int (*Avoid_WARNING_int_FSM)(FSM *pFSM);
-typedef int (*Avoid_WARNING_int_data)(void *data);
+typedef void (*Avoid_WARNING_State_Fcns)(void *data);
+typedef int (*Avoid_WARNING_Transition_Handler)(void *data, int curState);
+typedef void (*Avoid_WARNING_Overrider_Fcns)(FSM *pFsm);
+typedef int (*Avoid_WARNING_SelectEvent)(void *data);
 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 _FSMHandler{
-    int (**transitionTable)(FSM *pFSM);
-    void (**enterActionTable)(FSM *pFSM);
-    void (**duringActionTable)(FSM *pFSM);
-    void (**exitActionTable)(FSM *pFSM);
+    int (**transitionTable)(void *data, int currentState);
+
+    void (**enterActionTable)(void *data);
+    void (**delayActionTable)(void *data);
+    void (**duringActionTable)(void *data);
+    void (**exitActionTable)(void *data);
+
+    void (**childFSMStepTable)(FSM **cFSM);
 }FSMHandler;
 
 
 typedef struct _FSMPrivateVars
 {
     int curState;    
-    int defaultState; // Idle状态不能停留，必须指定一个初始状态
     int curEvent;
+    int defaultState; // Idle状态不能停留，必须指定一个初始状态
     int numEvent;
-
     int numChild;
     FSM **childFSM;
 
@@ -51,14 +73,13 @@ typedef struct _FSM
     FMSPrivateVars privateVars;
 
     // protected
+
     void *data;
 
 } FSM;
 
 
 // protected, 子类能用, 外界用不了
-int getFSMCurState(FSM *pFSM);
-int getFSMCurEvent(FSM *pFSM);
 void constructFSM(FSM* pFSM);
 
 // 继承的函数
diff --git a/FSM_OOP/baseFSM/FSM_public.h b/FSM_OOP/baseFSM/FSM_public.h
index 362ede5..7829675 100644
--- a/FSM_OOP/baseFSM/FSM_public.h
+++ b/FSM_OOP/baseFSM/FSM_public.h
@@ -1,13 +1,15 @@
 #ifndef __FSM_PUBLIC_H_
 #define __FSM_PUBLIC_H_
 
-
-#define     BASE_FSM(ptr)          ((FSM *)(ptr))
-#define     BASE_PTR               (FSM *)
+// #define     BASE_FSM(ptr)          ((FSM *)(ptr))
+// #define     BASE_PTR               (FSM *)
 
 typedef struct _FSM FSM;
 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;
 // 这几个函数可认为是虚函数, 构造函数里不会初始化FSMVtbl, 必须由子类重新实现
 typedef struct _FSMVtbl {
@@ -20,7 +22,8 @@ typedef struct _FSMVtbl {
 }FSMVtbl;
 
 
-
+int getFSMCurState(FSM *pFSM);
+int getFSMCurEvent(FSM *pFSM);
 void setEvent(FSM* pFSM);
 void setChildNum(FSM *pFSM, int num);
 void registerChildFSM(FSM *parent, FSM *child, int index);
diff --git a/FSM_OOP/template/templateFSM.c b/FSM_OOP/template/templateFSM.c
index 404537f..6dd06b7 100644
--- a/FSM_OOP/template/templateFSM.c
+++ b/FSM_OOP/template/templateFSM.c
@@ -40,19 +40,19 @@ static void initData(TemplateFSM *pFSM){   // 必须重新实现
 }
 
 static void setupHandler(FSMHandler* fcns){ // 必须重新实现
-    fcns->duringActionTable[E] = (Avoid_WARNING_void_FSM)actionFcn(during, E);
-    fcns->duringActionTable[D] = (Avoid_WARNING_void_FSM)actionFcn(during, D);
+    fcns->duringActionTable[E] = (Avoid_WARNING_State_Fcns)actionFcn(during, E);
+    fcns->duringActionTable[D] = (Avoid_WARNING_State_Fcns)actionFcn(during, D);
 
-    fcns->enterActionTable[D] = (Avoid_WARNING_void_FSM)actionFcn(enter, D);
-    fcns->enterActionTable[E] = (Avoid_WARNING_void_FSM)actionFcn(enter, E);
+    fcns->enterActionTable[D] = (Avoid_WARNING_State_Fcns)actionFcn(enter, D);
+    fcns->enterActionTable[E] = (Avoid_WARNING_State_Fcns)actionFcn(enter, E);
 
-    fcns->exitActionTable[D] = (Avoid_WARNING_void_FSM)D_exitAction;
-    fcns->exitActionTable[E] = (Avoid_WARNING_void_FSM)E_exitAction;
+    fcns->exitActionTable[D] = (Avoid_WARNING_State_Fcns)D_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, Idle2E)] = (Avoid_WARNING_int_FSM)transitionHandler(Idle2E);
-    fcns->transitionTable[index(D, D2E)] = (Avoid_WARNING_int_FSM)transitionHandler(D2E);
-    fcns->transitionTable[index(E, E2D)] = (Avoid_WARNING_int_FSM)transitionHandler(E2D);
+    fcns->transitionTable[index(Idle, Idle2D)] = (Avoid_WARNING_Transition_Handler)transitionHandler(Idle2D);
+    fcns->transitionTable[index(Idle, Idle2E)] = (Avoid_WARNING_Transition_Handler)transitionHandler(Idle2E);
+    fcns->transitionTable[index(D, D2E)] = (Avoid_WARNING_Transition_Handler)transitionHandler(D2E);
+    fcns->transitionTable[index(E, E2D)] = (Avoid_WARNING_Transition_Handler)transitionHandler(E2D);
 }
 
 /* 
@@ -64,9 +64,9 @@ TemplateFSM *createTemplateFSM(){
     TemplateFSM *pFSM;
     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.initData = (Avoid_WARNING_void_FSM)initData;
+    pFSM->base.vtbl.initData = (Avoid_WARNING_State_Fcns)initData;
     pFSM->base.vtbl.setupHandler = (Avoid_WARNING_void_fcns)setupHandler;
 
     constructFSM((FSM_Ptr)pFSM);
diff --git a/FSM_OOP/usr/keyFSM.c b/FSM_OOP/usr/keyFSM.c
index 476fe9e..6f15762 100644
--- a/FSM_OOP/usr/keyFSM.c
+++ b/FSM_OOP/usr/keyFSM.c
@@ -10,38 +10,28 @@
 */
 
 static Event selectEvent(KeyFSMData *data){   // 必须重新实现
-    if(data->countDelay == 4){
+
+    if(data->countDelay == 10){
         return HoldCount4;
     }
-
-    if(data->countDelay == 3){
-        if(data->countMultiDown && data->lastState == MultiDownWaiting){
-            return MultiDown;
-        }
-        if(data->lastState == Holding){
-            return UpDebouncing2Waiting;
-        }
+    else if(data->countDelay == 5){
         return DelayCount3;
     }
-
-    if(data->in == Up){
+    else if(data->in == Up){
         return PhsicalUp;
     }
     else{
-        if(data->lastState == Holding){
-            return UpDebouncing2Holding;
-        }
         return PhsicalDown;
     }
 }
 
 static void step(KeyFSM* pFSM){
     printFSM(pFSM);
-    stepBaseFSM(BASE_FSM(pFSM));
+    stepBaseFSM((FSM_Ptr)pFSM);
 
     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){   // 必须重新实现
@@ -50,54 +40,39 @@ static void initData(KeyFSM *pFSM){   // 必须重新实现
     data->countMultiDown = 0;
     data->in = Up;
     data->out = Idle;
-    data->lastState = 0;
 
     pFSM->base.data = data;
 }
 
 static void setupHandler(FSMHandler* fcns){ // 必须重新实现
-    fcns->duringActionTable[Waiting] = (Avoid_WARNING_void_FSM)actionFcn(during, Waiting);
-    fcns->exitActionTable[Waiting] = (Avoid_WARNING_void_FSM)actionFcn(exit, Waiting);
-
-    fcns->duringActionTable[DownDebouncing] = (Avoid_WARNING_void_FSM)actionFcn(during, DownDebouncing);
-    fcns->exitActionTable[DownDebouncing] = (Avoid_WARNING_void_FSM)actionFcn(exit, DownDebouncing);
-
-    fcns->duringActionTable[Downing] = (Avoid_WARNING_void_FSM)actionFcn(during, Downing);
-    fcns->exitActionTable[Downing] = (Avoid_WARNING_void_FSM)actionFcn(exit, Downing);
-
-    fcns->duringActionTable[UpDebouncing] = (Avoid_WARNING_void_FSM)actionFcn(during, UpDebouncing);
-    fcns->exitActionTable[UpDebouncing] = (Avoid_WARNING_void_FSM)actionFcn(exit, UpDebouncing);
-
-    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);
+    addStateActionFcn(enter, Waiting);
+    addStateActionFcn(during, DownDebouncing);
+    addStateActionFcn(during, Downing);
+    addStateActionFcn(delay, Downing);
+    addStateActionFcn(during, UpDebouncing);
+    addStateActionFcn(during, Holding);
+    addStateActionFcn(exit, Holding);
+    addStateActionFcn(during, MultiDownWaiting);
+    addStateActionFcn(delay, MultiDowning);
+    addStateActionFcn(during, HoldUpDebouncing);
+    addStateActionFcn(during, MultiDownDebouncing);
 
 
-    fcns->transitionTable[index(Waiting, PhsicalDown)] = (Avoid_WARNING_int_FSM)transitionHandler(PhsicalDown);
-
-    fcns->transitionTable[index(DownDebouncing, PhsicalUp)] = (Avoid_WARNING_int_FSM)transitionHandler(PhsicalUp);
-    fcns->transitionTable[index(DownDebouncing, DelayCount3)] = (Avoid_WARNING_int_FSM)transitionHandler(DelayCount3);
-    fcns->transitionTable[index(DownDebouncing, MultiDown)] = (Avoid_WARNING_int_FSM)transitionHandler(MultiDown);
-
-    fcns->transitionTable[index(Downing, PhsicalUp)] = (Avoid_WARNING_int_FSM)transitionHandler(PhsicalUp);
-    fcns->transitionTable[index(Downing, HoldCount4)] = (Avoid_WARNING_int_FSM)transitionHandler(HoldCount4);
-
-    fcns->transitionTable[index(UpDebouncing, PhsicalDown)] = (Avoid_WARNING_int_FSM)transitionHandler(PhsicalDown);
-    fcns->transitionTable[index(UpDebouncing, DelayCount3)] = (Avoid_WARNING_int_FSM)transitionHandler(DelayCount3);
-    fcns->transitionTable[index(UpDebouncing, UpDebouncing2Holding)] = (Avoid_WARNING_int_FSM)transitionHandler(UpDebouncing2Holding);
-    fcns->transitionTable[index(UpDebouncing, UpDebouncing2Waiting)] = (Avoid_WARNING_int_FSM)transitionHandler(UpDebouncing2Waiting);
-
-    fcns->transitionTable[index(Holding, PhsicalUp)] = (Avoid_WARNING_int_FSM)transitionHandler(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);
-    
+    addTransitionHandler(Waiting, PhsicalDown);
+    addTransitionHandler(DownDebouncing, PhsicalUp);
+    addTransitionHandler(DownDebouncing, DelayCount3);
+    addTransitionHandler(Downing, PhsicalUp);
+    addTransitionHandler(Downing, HoldCount4);
+    addTransitionHandler(UpDebouncing, PhsicalDown);
+    addTransitionHandler(UpDebouncing, DelayCount3);
+    addTransitionHandler(Holding, PhsicalUp);
+    addTransitionHandler(MultiDownWaiting, PhsicalDown);
+    addTransitionHandler(MultiDownWaiting, DelayCount3);
+    addTransitionHandler(MultiDowning, PhsicalUp);
+    addTransitionHandler(HoldUpDebouncing, PhsicalDown);
+    addTransitionHandler(HoldUpDebouncing, DelayCount3);
+    addTransitionHandler(MultiDownDebouncing, DelayCount3);
+    addTransitionHandler(MultiDownDebouncing, PhsicalUp);
 }
 
 /* 
@@ -109,9 +84,12 @@ KeyFSM *createKeyFSM(){
     KeyFSM *pFSM;
     pFSM = (KeyFSM *)newBaseFSM(Count_State, Count_Event, DEFAULT_STATE);
 
-    pFSM->base.vtbl.step = (Avoid_WARNING_void_FSM)step;
-    pFSM->base.vtbl.selectEvent = (Avoid_WARNING_int_data)selectEvent;
-    pFSM->base.vtbl.initData = (Avoid_WARNING_void_FSM)initData;
+#ifndef DSP28377
+    pFSM->base.vtbl.step = (Avoid_WARNING_Overrider_Fcns)step;
+#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;
 
     constructFSM((FSM_Ptr)pFSM);
diff --git a/FSM_OOP/usr/keyFSM.h b/FSM_OOP/usr/keyFSM.h
index 127a162..022df66 100644
--- a/FSM_OOP/usr/keyFSM.h
+++ b/FSM_OOP/usr/keyFSM.h
@@ -2,6 +2,8 @@
 #define __KEY_FSM_H_
 
 
+
+
 typedef enum _keyIn{
     Up,
     pDown,
@@ -16,13 +18,21 @@ typedef enum _keyOutSignal{
     Down_3times,
 }KeyOutSignal;
 
+const static char *keyStr[] = 
+{
+    "Idle",
+    "Down",
+    "Hold",
+    "Down_2times",
+    "Down_3times",
+};
+
 typedef struct _keyFSMData
 {
     int countDelay;
     int countMultiDown;
     KeyIn in;
     KeyOutSignal out;
-    int lastState;
 }KeyFSMData;
 
 typedef struct _KeyFSM KeyFSM;
diff --git a/FSM_OOP/usr/keyFSM_private.h b/FSM_OOP/usr/keyFSM_private.h
index 269b343..a3d6bf3 100644
--- a/FSM_OOP/usr/keyFSM_private.h
+++ b/FSM_OOP/usr/keyFSM_private.h
@@ -29,102 +29,89 @@ typedef enum _State
     UpDebouncing,
     MultiDownWaiting,
     MultiDowning,
+    HoldUpDebouncing,
+    MultiDownDebouncing,
 
     Count_State,
 } State;
 #define     DEFAULT_STATE       Waiting
 
 
-static void actionFcn(during, Waiting)(KeyFSM *pFSM){
-    KeyFSMData * data = pFSM->base.data;
-    data->out = Idle;
-}
-static void actionFcn(exit, Waiting)(KeyFSM *pFSM){
-    KeyFSMData * data = pFSM->base.data;
+static void actionFcn(enter, Waiting)(KeyFSMData* data){
+ 
     data->out = Idle;
+    data->countDelay = 0;
+    data->countMultiDown = 0;
 }
 
 
-
-static void actionFcn(during, DownDebouncing)(KeyFSM *pFSM)
+static void actionFcn(during, DownDebouncing)(KeyFSMData* data)
 {
-    KeyFSMData * data = pFSM->base.data;
+ 
     data->countDelay++;
-    printf(" during开启消抖 ");
+    FSM_LOG(" during开启消抖 ");
 }
 
-static void actionFcn(exit, DownDebouncing)(KeyFSM *pFSM){
-    KeyFSMData * data = pFSM->base.data;
-    data->lastState = Idle_State;
-}
-
-
-
-static void actionFcn(during, Downing)(KeyFSM *pFSM)
+static void actionFcn(delay, Downing)(KeyFSMData* data)
 {
-    KeyFSMData * data = pFSM->base.data;
+    data->out = Idle;
+}
+static void actionFcn(during, Downing)(KeyFSMData* data)
+{
+ 
     data->countDelay++;
     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){
-    KeyFSMData * data = pFSM->base.data;
+static void actionFcn(during, UpDebouncing)(KeyFSMData* data){
+ 
     data->countDelay++;
-    printf(" during松开消抖 ");
-}
-static void actionFcn(exit, UpDebouncing)(KeyFSM *pFSM){
-    KeyFSMData * data = pFSM->base.data;
-    data->lastState = Idle_State;
+    FSM_LOG(" during松开消抖 ");
 }
 
 
-
-
-static void actionFcn(during, Holding)(KeyFSM *pFSM){
-    KeyFSMData * data = pFSM->base.data;
+static void actionFcn(during, Holding)(KeyFSMData* data){
+    data->out = Idle;
     data->countDelay++;
     if(data->countDelay == 2){
         data->out = Hold;
         data->countDelay = 0;
     }
-    else{
-        data->out = Idle;
-    }
 }
 
-static void actionFcn(exit, Holding)(KeyFSM *pFSM){
-    KeyFSMData * data = pFSM->base.data;
+static void actionFcn(exit, Holding)(KeyFSMData* data){
     data->out = Idle;
 }
 
 
 
-static void actionFcn(during, MultiDownWaiting)(KeyFSM *pFSM){
-    KeyFSMData * data = pFSM->base.data;
+static void actionFcn(during, MultiDownWaiting)(KeyFSMData* data){
     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;
 }
 
-static void actionFcn(exit, MultiDowning)(KeyFSM *pFSM){
-    KeyFSMData * data = pFSM->base.data;
-    data->out = Idle;
+
+static void actionFcn(during, HoldUpDebouncing)(KeyFSMData* data)
+{
+    data->countDelay++;
 }
 
 
+static void actionFcn(during, MultiDownDebouncing)(KeyFSMData* data)
+{
+    data->countDelay++;
+}
+
+
+
 
 /* 
     事件和对应的转移函数
@@ -135,54 +122,47 @@ typedef enum _Event{
     PhsicalDown,
     PhsicalUp,
     DelayCount3,
-
     HoldCount4,
-    MultiDown,
-    UpDebouncing2Holding,
-    UpDebouncing2Waiting,
 
     Count_Event,
 }Event;
 
-static State transitionHandler(PhsicalDown)(KeyFSM *pFSM)
+static State transitionHandler(PhsicalDown)(KeyFSMData* data, State curState)
 {
-    printf(" 物理按键按下 ");
-    KeyFSMData * data = pFSM->base.data;
+    FSM_LOG(" 物理按键按下 ");
     data->countDelay = 0;
-    switch (getFSMCurState((FSM_Ptr)pFSM))
+ 
+    switch (curState)
     {
     case Waiting:
         return DownDebouncing;
         
     case UpDebouncing:
-        if(data->countMultiDown){
+        if(data->countMultiDown)
             return MultiDowning;
-        }
-
-        if(data->lastState == Holding){
-            data->lastState = Idle_State;
-            return Holding;
-        }
         else
             return Downing;
 
+    case HoldUpDebouncing:
+        return Holding;
+
     case MultiDownWaiting:
-        data->lastState = MultiDownWaiting;
-        return DownDebouncing;
+        return MultiDownDebouncing;
+
 
     default:
-        printf("检查状态转移表设计，不应该到这里");
+        FSM_LOG("检查状态转移表设计，不应该到这里");
         assert(0);
        
     }
 }
 
-static State transitionHandler(PhsicalUp)(KeyFSM *pFSM)
+static State transitionHandler(PhsicalUp)(KeyFSMData* data, State curState)
 {
-    printf(" 物理按键松开 ");
-    KeyFSMData * data = pFSM->base.data;
+    FSM_LOG(" 物理按键松开 ");
     data->countDelay = 0;
-    switch (getFSMCurState((FSM_Ptr)pFSM))
+ 
+    switch (curState)
     {
     case DownDebouncing:
         if(data->countMultiDown){
@@ -193,99 +173,76 @@ static State transitionHandler(PhsicalUp)(KeyFSM *pFSM)
     case Downing:
         return UpDebouncing;
     case Holding:
-        data->lastState = Holding;
-        return UpDebouncing;
+        return HoldUpDebouncing;
 
     case MultiDowning:
         return UpDebouncing;
 
     default:
-        printf("检查状态转移表设计，不应该到这里");
+        FSM_LOG("检查状态转移表设计，不应该到这里");
         assert(0);
 
     }
 }
 
-static State transitionHandler(DelayCount3)(KeyFSM *pFSM){
-    printf(" 延迟计数到3 ");
-    KeyFSMData * data = pFSM->base.data;
+static State transitionHandler(DelayCount3)(KeyFSMData* data, State curState){
+    FSM_LOG(" 延迟计数到3 ");
     data->countDelay = 0;
-    switch (getFSMCurState((FSM_Ptr)pFSM))
+    
+    switch (curState)
     {
     case DownDebouncing:
         data->out = Down;
-        
-        printf("按键按下");
+        FSM_LOG("按键按下");
         return Downing;
 
     case UpDebouncing:
         data->out = Up;
         data->countMultiDown++;
 
-        printf("按键松开");
+        FSM_LOG("按键松开");
         return MultiDownWaiting;
 
     case MultiDownWaiting:
-        data->out = Idle;
-        data->countMultiDown = 0;
         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:
-        printf("检查状态转移表设计，不应该到这里");
+        FSM_LOG("检查状态转移表设计，不应该到这里");
         assert(0);
     }
 }
 
 
-static State transitionHandler(HoldCount4)(KeyFSM *pFSM){
-    printf(" 计数到2进入长按模式 ");
-    KeyFSMData * data = pFSM->base.data;
+static State transitionHandler(HoldCount4)(KeyFSMData* data, State curState){
+    FSM_LOG(" 计数到2进入长按模式 ");
     data->countDelay = 0;
+ 
     data->out = Hold;
     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 
@@ -299,6 +256,8 @@ const static char *stateStr[] = {
     "UpDebouncing",
     "MultiDownWaiting",
     "MultiDowning",
+    "HoldUpDebouncing",
+    "MultiDownDebouncing",
     };
 const static char *eventStr[] = {
     "Idle",
@@ -306,13 +265,11 @@ const static char *eventStr[] = {
     "PhsicalUp",
     "DelayCount3",
     "HoldCount4",
-    "MultiDown",
-    "UpDebouncing2Holding",
-    "UpDebouncing2Waiting"
 };
 static void printFSM(KeyFSM* pFSM){
-    printf("\tKeyFSM: ");
-    printf("当前状态:%s, \t\t当前事件:%s, \t\t转移：", stateStr[getFSMCurState((FSM_Ptr)pFSM)], eventStr[getFSMCurEvent((FSM_Ptr)pFSM)]);
+    KeyFSMData* data = pFSM->base.data;
+    FSM_LOG("KeyFSM: ");
+    FSM_LOG("%d, 当前状态:%s, \t当前事件:%s \t转移：",  data->countDelay, stateStr[getFSMCurState((FSM_Ptr)pFSM)], eventStr[getFSMCurEvent((FSM_Ptr)pFSM)]);
 }
 
 
diff --git a/main.c b/main.c
index 175ee8f..5052178 100644
--- a/main.c
+++ b/main.c
@@ -19,6 +19,12 @@ KeyIn testin[NUM] = {
     pDown,pDown,pDown,pDown
 };
 
+typedef void (*fcn)();
+
+void printtest(){
+    printf("fcn\n");
+}
+
 
 int main(){
 
@@ -29,8 +35,9 @@ int main(){
         printf("第%d次: ",i+1);
         KeyFSMData* data = getData((FSM_Ptr)keyFSM);
         data->in = testin[i];
-        setEvent((FSM_Ptr)keyFSM);
-        vptrFSM((FSM_Ptr)keyFSM)->step((FSM_Ptr)keyFSM);
+
+        SetEvent(keyFSM);
+        Step(keyFSM);
 
         if(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;
 }
\ No newline at end of file
diff --git a/状态图.png b/状态图.png
index a6bbdba..bfa7408 100644
Binary files a/状态图.png and b/状态图.png differ