状态机

//header

typedef struct {
    POWERMODING_STATE_TYPE stateId;//状态名
    void (*onStateEnter)();//进入状态
    void (*stateSigProc)(POWERMODING_SIGNAL pmSignal);//状态处理
    void (*onStateExit)();//退出状态
} PMStateType;


/*不同状态*/
typedef struct {
    PMStateType pmSleepState;
    PMStateType pmActiveState;
    PMStateType pmSlientState;
	PMStateType pmNullState;
    PMStateType *pCurPmState;

} PMStateMachineType;


typedef enum {
    PWR_STATE_NO_PRESS = 0,
    PWR_STATE_SHORTPRESS_ON,
    PWR_STATE_LONGPRESS_ON,

} PWR_STATE_TYPE;

//initalize and process

void onEnterPMSleepState();
void onExitPMSleepOffState();
void sigProcPMSleepOffState(POWERMODING_SIGNAL sig);

//
void onEnterPMActiveState();
void onExitPMActiveState();
void sigProcPMActiveState(POWERMODING_SIGNAL sig);

//
void onEnterPMSlientState();
void onExitPMSlientState();
void sigProcPMSlientState(POWERMODING_SIGNAL sig);

void onEnterPMNULLState();
void onExitPMNULLState();
void sigProcPMNULLState(POWERMODING_SIGNAL sig);
void Initialize_StateMachine(void);

<span style="font-family: Arial, Helvetica, sans-serif;">void Initialize_StateMachine(void)//</span>

{
    PMStateMachineType *pStm = &pmStateMachine;


    pStm->pmSleepState.stateId = PM_SLEEP_STATE;
    pStm->pmSleepState.onStateEnter = onEnterPMSleepState;
    pStm->pmSleepState.onStateExit = onExitPMSleepState;
    pStm->pmSleepState.stateSigProc = sigProcPMSleepState;


    pStm->pmActiveState.stateId = PM_ACTIVE_STATE;
    pStm->pmActiveState.onStateEnter = onEnterPMActiveState;
    pStm->pmActiveState.onStateExit = onExitPMActiveState;
    pStm->pmActiveState.stateSigProc = sigProcPMActiveState;


    pStm->pmSlientState.stateId = PM_SLIENT_STATE;
    pStm->pmSlientState.onStateEnter = onEnterPMSlientState;
    pStm->pmSlientState.onStateExit = onExitPMSlientState;
    pStm->pmSlientState.stateSigProc = sigProcPMSlientState;

}<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">//receive event and jump</span>

static void powerModingMainLoop()//arguement

{
    TaskSignal tSignals;
    static uint32_t test = 0;
    //PMStateMachineType *pStm = &pmStateMachine;

    //ServiceSignalRegister(TESTSERVICE_SIGNAL_TEST1);

    while(1) {

        /* wait for events indefinitely and clear after end of function */
        tSignals = TaskWaitEventWithTimeout(&powerModingStubInstance, (
                                                EVENT_PM_TIMER_TICK_10MS            |
                                                EVENT_PM_ACC_ON                     |
                                                EVENT_PM_ACC_OFF                    |
                                                EVENT_PM_LOW                        |//6v<=power voltage<=9v
                                                EVENT_PM_ULTRA_LOW                  |//9v<power voltage<=17
                                                EVENT_PM_TEMP_INVLIAD               |
                                                EVENT_PM_PWK_SHORT_PRESSED          |
                                                EVENT_PM_PWK_LONG_PRESSED           |
                                                EVENT_PM_CAN_SLEEP_REQ               //no message tx/rx on CAN Bus
                                            ),
                                            (uint16_t) OS_WAITFOREVER);



        //Signal Handling
        test = tSignals;
        if (tSignals & EVENT_PM_TIMER_TICK_10MS) {
			//TracePrintf(MOD_TRACE, TRACE_INFO, "EVENT_PM_TIMER_TICK_10MS\n\r");
            VehicleSignalAccScan();
            VehicleSignalVoltageScan();
            VehicleSignalTempScan();
            //2 TODO:temperature??
            Process_StateMachine(PM_SIG_TIMER_TICK_10MS);
        } else if (tSignals & EVENT_PM_ACC_ON) {
            Process_StateMachine(PM_SIG_ACC_ON);
        } else if (tSignals & EVENT_PM_ACC_OFF) {
            Process_StateMachine(PM_SIG_ACC_OFF);
        } else if (tSignals & EVENT_PM_LOW) {
            Process_StateMachine(PM_SIG_LOW);
        } else if (tSignals & EVENT_PM_ULTRA_LOW) {
            Process_StateMachine(PM_SIG_ULTRA_LOW);
        }  else if (tSignals & EVENT_PM_TEMP_INVLIAD) {
            Process_StateMachine(PM_SIG_TEMP_INVLIAD);
        } else if (tSignals & EVENT_PM_PWK_SHORT_PRESSED) {
            Process_StateMachine(PM_SIG_PWK_SHORT_PRESSED);
        } else if (tSignals & EVENT_PM_PWK_LONG_PRESSED) {
            Process_StateMachine(PM_SIG_PWK_LONG_PRESSED);
        } else if(tSignals & EVENT_PM_CAN_SLEEP_REQ) {
            Process_StateMachine(PM_SIG_CAN_SLEEP);//
        }
    }

}