Merge branch 'release/28377测试ok'

FSM_OOP/usr/keyFSM.c

@@ -10,17 +10,27 @@
 */
 
 static Event selectEvent(KeyFSMData *data){   // 必须重新实现
-    if(data->countDelay == 10){
+    if(data->countDelay == 4){
-        return HoldCount10;
+        return HoldCount4;
     }
 
-    if(data->countDelay == 5){
+    if(data->countDelay == 3){
-        return DelayCount5;
+        if(data->countMultiDown && data->lastState == MultiDownWaiting){
+            return MultiDown;
+        }
+        if(data->lastState == Holding){
+            return UpDebouncing2Waiting;
+        }
+        return DelayCount3;
     }
+
     if(data->in == Up){
         return PhsicalUp;
     }
     else{
+        if(data->lastState == Holding){
+            return UpDebouncing2Holding;
+        }
         return PhsicalDown;
     }
 }
@@ -31,7 +41,7 @@ static void step(KeyFSM* pFSM){
 
     KeyFSMData * data = pFSM->base.data;
 
-    printf("  信号:%d", data->out);
+    printf("\t信号:%d, 计数%d, 上次状态%s", data->out, data->countDelay, stateStr[data->lastState]);
 }
 
 static void initData(KeyFSM *pFSM){   // 必须重新实现
@@ -40,7 +50,7 @@ static void initData(KeyFSM *pFSM){   // 必须重新实现
     data->countMultiDown = 0;
     data->in = Up;
     data->out = Idle;
-    data->isLastHolding = 0;
+    data->lastState = 0;
 
     pFSM->base.data = data;
 }
@@ -50,27 +60,44 @@ static void setupHandler(FSMHandler* fcns){ // 必须重新实现
     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);
 
 
     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, DelayCount5)] = (Avoid_WARNING_int_FSM)transitionHandler(DelayCount5);
+    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, HoldCount10)] = (Avoid_WARNING_int_FSM)transitionHandler(HoldCount10);
+    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, DelayCount5)] = (Avoid_WARNING_int_FSM)transitionHandler(DelayCount5);
+    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);
+    
 }
 
 /* 

FSM_OOP/usr/keyFSM.h

@@ -22,7 +22,7 @@ typedef struct _keyFSMData
     int countMultiDown;
     KeyIn in;
     KeyOutSignal out;
-    int isLastHolding;
+    int lastState;
 }KeyFSMData;
 
 typedef struct _KeyFSM KeyFSM;

FSM_OOP/usr/keyFSM_private.h

@@ -27,7 +27,8 @@ typedef enum _State
     Downing,
     Holding,
     UpDebouncing,
-    MultiClickWaiting,
+    MultiDownWaiting,
+    MultiDowning,
 
     Count_State,
 } State;
@@ -52,6 +53,12 @@ static void actionFcn(during, DownDebouncing)(KeyFSM *pFSM)
     printf(" during开启消抖 ");
 }
 
+static void actionFcn(exit, DownDebouncing)(KeyFSM *pFSM){
+    KeyFSMData * data = pFSM->base.data;
+    data->lastState = Idle_State;
+}
+
+
 
 static void actionFcn(during, Downing)(KeyFSM *pFSM)
 {
@@ -70,8 +77,13 @@ static void actionFcn(exit, Downing)(KeyFSM *pFSM)
 static void actionFcn(during, UpDebouncing)(KeyFSM *pFSM){
     KeyFSMData * data = pFSM->base.data;
     data->countDelay++;
-    printf(" during开启消抖 ");
+    printf(" during松开消抖 ");
 }
+static void actionFcn(exit, UpDebouncing)(KeyFSM *pFSM){
+    KeyFSMData * data = pFSM->base.data;
+    data->lastState = Idle_State;
+}
+
 
 
 
@@ -87,6 +99,30 @@ static void actionFcn(during, Holding)(KeyFSM *pFSM){
     }
 }
 
+static void actionFcn(exit, Holding)(KeyFSM *pFSM){
+    KeyFSMData * data = pFSM->base.data;
+    data->out = Idle;
+}
+
+
+
+static void actionFcn(during, MultiDownWaiting)(KeyFSM *pFSM){
+    KeyFSMData * data = pFSM->base.data;
+    data->countDelay++;
+    printf(" during多击等待 ");
+}
+
+
+static void actionFcn(during, MultiDowning)(KeyFSM *pFSM)
+{
+    KeyFSMData * data = pFSM->base.data;
+    data->out = Idle;
+}
+
+static void actionFcn(exit, MultiDowning)(KeyFSM *pFSM){
+    KeyFSMData * data = pFSM->base.data;
+    data->out = Idle;
+}
 
 
 
@@ -98,9 +134,12 @@ typedef enum _Event{
     Idle_Event,
     PhsicalDown,
     PhsicalUp,
-    DelayCount5,
+    DelayCount3,
 
-    HoldCount10,
+    HoldCount4,
+    MultiDown,
+    UpDebouncing2Holding,
+    UpDebouncing2Waiting,
 
     Count_Event,
 }Event;
@@ -116,13 +155,21 @@ static State transitionHandler(PhsicalDown)(KeyFSM *pFSM)
         return DownDebouncing;
         
     case UpDebouncing:
-        if(data->isLastHolding){
+        if(data->countMultiDown){
-            data->isLastHolding = 0;
+            return MultiDowning;
+        }
+
+        if(data->lastState == Holding){
+            data->lastState = Idle_State;
             return Holding;
         }
         else
             return Downing;
 
+    case MultiDownWaiting:
+        data->lastState = MultiDownWaiting;
+        return DownDebouncing;
+
     default:
         printf("检查状态转移表设计，不应该到这里");
         assert(0);
@@ -138,13 +185,20 @@ static State transitionHandler(PhsicalUp)(KeyFSM *pFSM)
     switch (getFSMCurState((FSM_Ptr)pFSM))
     {
     case DownDebouncing:
+        if(data->countMultiDown){
+            return MultiDownWaiting;
+        }
         return Waiting;
 
     case Downing:
         return UpDebouncing;
     case Holding:
-        data->out = Idle;
+        data->lastState = Holding;
         return UpDebouncing;
+
+    case MultiDowning:
+        return UpDebouncing;
+
     default:
         printf("检查状态转移表设计，不应该到这里");
         assert(0);
@@ -152,24 +206,28 @@ static State transitionHandler(PhsicalUp)(KeyFSM *pFSM)
     }
 }
 
-static State transitionHandler(DelayCount5)(KeyFSM *pFSM){
+static State transitionHandler(DelayCount3)(KeyFSM *pFSM){
-    printf(" 延迟计数到5 ");
+    printf(" 延迟计数到3 ");
-
     KeyFSMData * data = pFSM->base.data;
+    data->countDelay = 0;
     switch (getFSMCurState((FSM_Ptr)pFSM))
     {
     case DownDebouncing:
         data->out = Down;
-        data->countDelay = 0;
         
         printf("按键按下");
         return Downing;
 
     case UpDebouncing:
         data->out = Up;
-        data->countDelay = 0;
+        data->countMultiDown++;
 
         printf("按键松开");
+        return MultiDownWaiting;
+
+    case MultiDownWaiting:
+        data->out = Idle;
+        data->countMultiDown = 0;
         return Waiting;
 
     default:
@@ -179,17 +237,55 @@ static State transitionHandler(DelayCount5)(KeyFSM *pFSM){
 }
 
 
-static State transitionHandler(HoldCount10)(KeyFSM *pFSM){
+static State transitionHandler(HoldCount4)(KeyFSM *pFSM){
-    printf(" 计数到10进入长按模式 ");
+    printf(" 计数到2进入长按模式 ");
     KeyFSMData * data = pFSM->base.data;
     data->countDelay = 0;
     data->out = Hold;
-    data->isLastHolding = 1;
     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 
@@ -201,18 +297,22 @@ const static char *stateStr[] = {
     "Downing",
     "Holding",
     "UpDebouncing",
-    "MultiClickWaiting",
+    "MultiDownWaiting",
+    "MultiDowning",
     };
 const static char *eventStr[] = {
     "Idle",
     "PhsicalDown",
     "PhsicalUp",
-    "DelayCount5",
+    "DelayCount3",
-    "HoldCount10",
+    "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)]);
+    printf("当前状态:%s, \t\t当前事件:%s, \t\t转移：", stateStr[getFSMCurState((FSM_Ptr)pFSM)], eventStr[getFSMCurEvent((FSM_Ptr)pFSM)]);
 }
 
 

main.c

@@ -3,16 +3,15 @@
 #include "keyFSM.h"
 #include "FSM_public.h"
 
-#define     NUM     50
+#define     NUM     60
-// KeyIn testin[NUM] = {
+
-//     Up,Up,Up,Up,Up,                     Up,pDown,pDown,pDown,Up,        pDown,pDown,pDown,pDown,pDown, 
-//     pDown,pDown,pDown,Up,Up,            pDown,pDown,
-// };
 
 KeyIn testin[NUM] = {
     Up,Up,pDown,pDown,Up,               
     pDown,pDown,pDown,pDown,pDown, 
-    pDown,pDown,pDown,Up,Up, 
+    pDown,pDown,pDown,pDown,pDown, 
+    Up,Up,Up,Up,Up,
+    Up,Up,pDown,pDown,pDown, 
     pDown,pDown,pDown,pDown,pDown, 
     pDown,pDown,pDown,pDown,pDown, 
     pDown,pDown,pDown,pDown,pDown, 
@@ -33,11 +32,15 @@ int main(){
         setEvent((FSM_Ptr)keyFSM);
         vptrFSM((FSM_Ptr)keyFSM)->step((FSM_Ptr)keyFSM);
 
+        if(data->out){
+            printf("\t\t\t\t%d", data->out);    
+        }
+        
+
         printf("\n");
     }
 
 
-
     printf("hello world, 你好世界");
 
     return 0;