FSM/vscode/FSM_OOP/keytest/keyFSM_private.h

#ifndef __KEY_PRIVATE_FSM_H_
#define __KEY_PRIVATE_FSM_H_

#include "FSM_protected.h"
#include "keyFSM.h"
#include <stdio.h>
#include <assert.h>

/* 
    继承基类
 */
typedef struct _KeyFSM
{   
    // 继承父类
    FSM base;
}KeyFSM;

/* 
    状态和对应的 action, exit, during 函数
 */

typedef enum _State
{
    Idle_State,
    Waiting,
    DownDebouncing,
    Downing,
    Holding,
    HoldUpDebouncing,
    UpDebouncing,
    MultiDownWaiting,
    MultiDowning,
    MultiDownDebouncing,

    Count_State,
} State;
#define     DEFAULT_STATE       Waiting

/* -------------------------------------------------------------------------- */
/*                         下一个状态选择函数                                 */
/* -------------------------------------------------------------------------- */
static State selectNextStateFcn(Waiting)(KeyFSMData *data){
    if(data->in == Down){
        FSM_LOG(" 物理按键按下 ");
        return DownDebouncing;
    }
    return Idle_State;
}

static State selectNextStateFcn(DownDebouncing)(KeyFSMData *data){
    if(data->in == Up){
        FSM_LOG(" 物理按键松开 ");
        return Waiting;
    }
    else if(data->countDelay == 5){
        return Downing;
    }
    return Idle_State;
}

static State selectNextStateFcn(Downing)(KeyFSMData *data){
    if(data->in == Up){
        FSM_LOG(" 物理按键松开 ");
        return UpDebouncing;
    }
    else if(data->countDelay == 10){
        return Holding;
    }
    return Idle_State;
}

static State selectNextStateFcn(Holding)(KeyFSMData *data){
    if(data->in == Up){
        FSM_LOG(" 物理按键松开 ");
        return HoldUpDebouncing;
    }
    return Idle_State;
}

static State selectNextStateFcn(HoldUpDebouncing)(KeyFSMData *data){
    if(data->in == Down){
        FSM_LOG(" 物理按键按下 ");
        return Holding;
    }
    else if(data->countDelay == 5){
        return Waiting;
    }
    return Idle_State;
}

static State selectNextStateFcn(UpDebouncing)(KeyFSMData *data){
    if(data->in == Down){
        FSM_LOG(" 物理按键按下 ");
        if(data->countMultiDown){
            return MultiDowning;
        }
        else{
            return Downing;
        }
    }
    else if(data->countDelay == 5){
        return MultiDownWaiting;
    }

    return Idle_State;
}

static State selectNextStateFcn(MultiDownWaiting)(KeyFSMData *data){
    if(data->in == Down){
        FSM_LOG(" 物理按键按下 ");
        return MultiDownDebouncing;
    }
    else if(data->countDelay == 5){
        return Waiting;
    }
    return Idle_State;
}

static State selectNextStateFcn(MultiDowning)(KeyFSMData *data){
    if(data->in == Up){
        FSM_LOG(" 物理按键松开 ");
        return UpDebouncing;
    }
    return Idle_State;
}

static State selectNextStateFcn(MultiDownDebouncing)(KeyFSMData *data){
    if(data->in == Up){
        FSM_LOG(" 物理按键松开 ");
        return MultiDownWaiting;
    }
    else if(data->countDelay == 5){
        return MultiDowning;
    }
    return Idle_State;
}

/* -------------------------------------------------------------------------- */
/*                    对应的 action, exit, during 函数                        */
/* -------------------------------------------------------------------------- */
static void actionFcn(enter, Waiting)(KeyFSMData* data){
    data->out = Idle;
    data->countDelay = 0;
    data->countMultiDown = 0;
}


static void actionFcn(during, DownDebouncing)(KeyFSMData* data)
{
    data->countDelay++;
    FSM_LOG(" during开启消抖 ");
}

static void actionFcn(during, Downing)(KeyFSMData* data)
{
 
    data->countDelay++;
    data->out = Idle;
}



static void actionFcn(during, UpDebouncing)(KeyFSMData* data){
 
    data->countDelay++;
    FSM_LOG(" during松开消抖 ");
}


static void actionFcn(during, Holding)(KeyFSMData* data){
    data->out = Idle;
    data->countDelay++;
    if(data->countDelay == 2){
        data->out = Hold;
        data->countDelay = 0;
    }
}

static void actionFcn(exit, Holding)(KeyFSMData* data){
    data->out = Idle;
}



static void actionFcn(during, MultiDownWaiting)(KeyFSMData* data){
    data->countDelay++;
    FSM_LOG(" during多击等待 ");
}



static void actionFcn(during, HoldUpDebouncing)(KeyFSMData* data)
{
    data->countDelay++;
}


static void actionFcn(during, MultiDownDebouncing)(KeyFSMData* data)
{
    data->countDelay++;
}


/* -------------------------------------------------------------------------- */
/*                                转移函数                                    */
/* -------------------------------------------------------------------------- */
void transitionGeneralAction(KeyFSMData *data){
    data->countDelay = 0;
}

static State transitionHandler(DownDebouncing, Downing)(KeyFSMData* data){
    data->out = Down;
}


static State transitionHandler(UpDebouncing, MultiDownWaiting)(KeyFSMData* data){
    data->out = Idle;
    data->countMultiDown++;
}

static State transitionHandler(MultiDownDebouncing, MultiDowning)(KeyFSMData* data){
    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);
}


static State transitionHandler(Downing, Holding)(KeyFSMData* data){
    data->out = Hold;
}

static State transitionHandler(MultiDownWaiting, Waiting)(KeyFSMData* data){
    data->countMultiDown = 0;
}



/* 
    用户自定义事件选择逻辑—————————————————begin 
*/
const static char *stateStr[] = {
    "Idle",
    "Waiting",
    "DownDebouncing",
    "Downing",
    "Holding",
    "HoldUpDebouncing",
    "UpDebouncing",
    "MultiDownWaiting",
    "MultiDowning",
    "MultiDownDebouncing",
    };

static void printFSM(KeyFSM* pFSM){
    KeyFSMData* data = pFSM->base.privateVars.data;
    FSM_LOG("KeyFSM: ");
    FSM_LOG("%d, 当前状态:%s, \t上一个下次事件:%s \t转移：",  data->countDelay, stateStr[getFSMCurState((FSM *)pFSM)], stateStr[getFSMNextState((FSM *)pFSM)]);
}


#endif