FSM/vscode/FSM_OOP/baseFSM/FSM.c

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>

#include "FSM_private.h"
#include "FSM_protected.h"
#include "FSM_public.h"


 



/* -------------------------------------------------------------------------- */
/*                                private函数                                 */
/* -------------------------------------------------------------------------- */
/**
 * @brief 设置下一个状态，里面的子状态机暂时没用到
 * 
 * @param pFSM 状态机变量的基类指针
 */
static inline void setNextState(FSM* pFSM){
    int curState = pFSM->privateVars->curState;
    if(curState != 0){
        pFSM->signals.lastTriggeredSignal = Idle_Signal;
        pFSM->privateVars->nextState = pFSM->privateVars->fcns.selectNextState[curState](pFSM->data, &pFSM->signals);
        pFSM->privateVars->index = pFSM->privateVars->curState * pFSM->privateVars->numState + pFSM->privateVars->nextState;
    }

    if(0 == pFSM->privateVars->numChild)
        return;


    for (int i = 0; i < pFSM->privateVars->numChild; i++)
    {
        FSM *cFSM = pFSM->privateVars->childFSM[i];
        setNextState(cFSM);
    }
}

/**
 * @brief 
 * @deprecated 去掉了所有和预装载器相关的内容
 * @param pFSM 
 */
static inline void preload(FSM* pFSM){
    if(pFSM->privateVars->preloader.isReady){
        memcpy(pFSM->data, pFSM->privateVars->preloader.shadowData, pFSM->privateVars->preloader.size);
        pFSM->privateVars->preloader.isReady = 0;
    }    
}
  




/* -------------------------------------------------------------------------- */
/*                                  protected                                 */
/* -------------------------------------------------------------------------- */

/**
 * @brief 运行状态机，状态机框架的核心函数
 * @details 共分为三部首先判断是否有状态机切换，
 * @param pFSM 状态机基类指针
 */
void stepBaseFSM(FSM *pFSM)
{
    pFSM->pureVtbl.loadExternalData(pFSM->data);
    // preload(pFSM);
    setNextState(pFSM);
    pFSM->pureVtbl.resetSignals(&pFSM->signals, pFSM->data);
    
    FSMHandler *fcns = &pFSM->privateVars->fcns;
    int curState = pFSM->privateVars->curState;
    void *data = pFSM->data;
    FSM **childFSM = pFSM->privateVars->childFSM;
    int index = pFSM->privateVars->index;
    int nextState = pFSM->privateVars->nextState;


    
    if(nextState && curState != nextState){  // 状态切换
        if (fcns->exitActionTable[curState] != NULL)
            fcns->exitActionTable[curState](data, childFSM);

        if (fcns->transitionTable[index] != NULL) // 有特定的状态转移函数
            (*fcns->transitionTable[index])(data);

        if(fcns->transitionGeneralAction != NULL)
            fcns->transitionGeneralAction(data);    // 通用状态转移函数
            
        if (fcns->enterActionTable[nextState] != NULL)
            fcns->enterActionTable[nextState](data, childFSM);

        pFSM->privateVars->curState = nextState;
    }
    else if(curState == 0){ // 处理刚运行进入的默认状态
        nextState = pFSM->privateVars->defaultState;
        if (fcns->enterActionTable[nextState] != NULL)
            fcns->enterActionTable[nextState](data, childFSM);
        pFSM->privateVars->curState = nextState;
    }
    else    // 状态机没动
    {
        if (fcns->duringActionTable[curState] != NULL)
            fcns->duringActionTable[curState](data, childFSM);
    }
}


/* -------------------------------------------------------------------------- */
/*                                public 函数                                 */
/* -------------------------------------------------------------------------- */
void resetBaseFSM(FSM *pFSM)
{
    if (pFSM->privateVars->fcns.exitActionTable[pFSM->privateVars->curState] != NULL)
        pFSM->privateVars->fcns.exitActionTable[pFSM->privateVars->curState](pFSM->data, pFSM->privateVars->childFSM);

    pFSM->privateVars->curState = 0;
}

void _stepFSM(FSM *pFSM){
    pFSM->publicFcns.step(pFSM);
}


int getFSMCurState(FSM *pFSM){
    return pFSM->privateVars->curState;
}
int getFSMNextState(FSM *pFSM){
    return pFSM->privateVars->nextState;
}


void setChildNum(FSM *pFSM, int num){
    pFSM->privateVars->numChild = num;
    pFSM->privateVars->childFSM = (FSM **)calloc(num, sizeof(FSM *));
}

void registerChildFSM(FSM *parent, FSM *child, int index){
    parent->privateVars->childFSM[index] = child;
}

const void *_getData(FSM* pFSM){
    return (const void *)pFSM->data;
}

void _setSignal(FSM *pFSM, Uint16 signalFlag){
    pFSM->signals.all |= (1 << signalFlag);
}

/**
 * @brief 
 * @deprecated 弃用
 * @param pFSM 
 * @return void* 
 */
void *_preloadIn(FSM *pFSM){
    return pFSM->privateVars->preloader.shadowData;
}

/**
 * @brief 
 * @deprecated 弃用
 * @param pFSM 
 */
void _preloaderGetReady(FSM *pFSM){
    if(pFSM->privateVars->preloader.isReady){
        pFSM->privateVars->preloader.isOverflow = 1;
    }
    pFSM->privateVars->preloader.isReady = 1;
}

/**
 * @brief 
 * @deprecated 弃用
 * @param pFSM 
 * @return int 
 */
int _getPreloaderOverFlag(FSM *pFSM){
    return pFSM->privateVars->preloader.isOverflow;
}

/**
 * @brief 
 * @deprecated 弃用
 * @param pFSM 
 */
void _clearPreloaderOverFlag(FSM *pFSM){
    pFSM->privateVars->preloader.isOverflow = 0;
}




/* -------------------------------------------------------------------------- */
/*                   构造函数，分两段，先新建再赋值                            */
/* -------------------------------------------------------------------------- */
FSM*  newBaseFSM(int numState, int defaultState){
    typedef void (*StateFuncPtr)(void *); 
    typedef void (*ChildFSMStepFuncPtr)(FSM **); 
    typedef int (*TransitionFuncPtr)(void *, int *);
    typedef int (*SelectNextStateFcnPtr)(void *, FSMSignals *);

    FSM *pFSM = calloc(1, sizeof(FSM));
    pFSM->privateVars = newFMSPrivateVars(numState, defaultState);

    FSMPureVtbl pureVtbl = {
        .setupHandler = NULL,
        .initData = NULL,
        .loadExternalData = NULL,
        .initDataLoader = NULL,
        .initSignals = NULL,
        .resetSignals = NULL,
    };
    pFSM->pureVtbl = pureVtbl;

    pFSM->publicFcns.step = stepBaseFSM;
    pFSM->publicFcns.reset = resetBaseFSM;

    return pFSM;
}


void constructFSM(FSM* pFSM){
    assert(pFSM->pureVtbl.setupHandler);
    assert(pFSM->pureVtbl.initData);
    assert(pFSM->pureVtbl.initDataLoader);

    pFSM->pureVtbl.setupHandler(&pFSM->privateVars->fcns);
    pFSM->pureVtbl.initData(pFSM);
    pFSM->pureVtbl.initDataLoader(pFSM);

    /* ---------------------------------- 检查状态表 --------------------------------- */
    for (int i = 1; i < pFSM->privateVars->numState; i++) // 跳过Idle状态，Idle状态只能跳转到默认状态
    {
        if(!pFSM->privateVars->fcns.selectNextState[i]){
            FSM_LOG("每个状态都要有一个状态选择函数!\n");
            assert(0); // 强制退出
        }
    }
}