motor_ctl-4/User project/1.FrameLayer/Source/FSM_1st.c

/**
 * @file sysfsm1.c
 * @author Zhang, Kai(zhangkai71@midea.com)
 * @brief System FSM
 * @version 0.1
 * @date 2021-09-27
 *
 * @copyright Copyright (c) 2021
 *
 */
/******************************
 *
 *  Included File
 *
 ******************************/
#include "user.h"
#include "FSM_1st.h"
#include "FSM_2nd.h"
#include "FuncLayerAPI.h"
#include "power.h"
#include "canAppl.h"
/******************************
 *
 *  Parameter
 *
 ******************************/
FSM_SYS_HOOK   FSM1st_Sys_state;
static FSM_SYS_HOOK   SysInit_state = {SysInit, SysInit_hook, SysInit_TbcUphook, SysInit_TbcDownhook, SysInit_Tbshook};
static FSM_SYS_HOOK   SysRdy_state = {SysRdy, SysRdy_hook, SysRdy_TbcUphook, SysRdy_TbcDownhook, SysRdy_Tbshook};
FSM_SYS_HOOK   SysFault_state = {SysFault, SysFault_hook, SysFault_TbcUphook, SysFault_TbcDownhook, SysFault_Tbshook};
SYS_FMS_FLAG   switch_flg = SYS_FSM_FLG_DEFAULT;
SYS_RDY_FLG    sysfsm_stFlg = SYS_RDY_FLG_DEFAULT;
SIGNAL_STATE   signal_state;
static void (*switchfuction[3][3])(void) = {ReadytoRun, ReadytoRun, ReadytoRun, ReadytoRun, ReadytoRun, ReadytoRun, ReadytoRun, ReadytoRun, ReadytoRun};
/******************************
 *
 *  Function
 *
 ******************************/
void FSM_voInit(void)
{
    FSM1st_Sys_state = SysInit_state;
    switch_flg.HMI_Flag = FALSE;
    switch_flg.SysRdy_Flag = FALSE;
    switch_flg.SysRun_Flag = FALSE;
    switch_flg.SysFault_Flag = FALSE;
    signal_state.Sensor = FALSE;
    signal_state.Assist = FALSE;
    signal_state.Switched = FALSE;
    signal_state.Light = FALSE;
    signal_state.Display = FALSE;
    sysfsm_stFlg.CommuRdy_Flag = TRUE;
}

void FSM_1st_Main(void)
{
    switch (FSM1st_Sys_state.state)
    {
    case SysInit:
        /* Fault detection*/
        if (switch_flg.SysFault_Flag == 1)
        {
            Switch_sys_FSM(&SysFault_state);
        }

        if (switch_flg.SysRdy_Flag == 1)
        {
            /* System FSM_2nd init */
            RUN_FSM_voInit();
            Switch_sys_FSM(&SysRdy_state);
        }
        
        break;
    case SysRdy:
        /* Fault detection*/
        if (switch_flg.SysFault_Flag == 1)
        {
            Switch_sys_FSM(&SysFault_state);
        }
        break;

    case SysFault:
        if (!switch_flg.SysFault_Flag)
        {
            alm_voHandleRst();
            Switch_sys_FSM(&SysInit_state);
        }
        break;

    default:
        break;
    }
}

void SysInit_hook(void)
{
    if (sysfsm_stFlg.blADCInitOvrFlg && sysfsm_stFlg.CommuRdy_Flag)
    {
        /* Bike Light Init */
        bikelight_voBikeLightInit();

        /* Bike Throttle Init */
        bikethrottle_voBikeThrottleInit();
       
        /* Torque Sensor Init */
        torsensor_voTorSensorInit();

        /* Bike Speed Init */
        bikespeed_voBikeSpeedInit();

        /* Bike Speed PI Init */
        bikespeed_voPIInit();
  
        /* Bike Brake Init */
        bikebrake_voBikeBrakeInit();

        /* Bike Cadence Init */
        cadence_voCadenceInit();

        switch_flg.SysRdy_Flag = TRUE;
    }
}

void SysInit_TbcUphook(void)
{
    adc_voCalibration(&adc_stCof, &adc_stDownOut, &adc_stUpOut);
}
void SysInit_TbcDownhook(void)
{}
void SysInit_Tbshook(void)
{}

void SysRdy_hook(void)
{
    /* System Coef Cal */
    if (switch_flg.SysCoef_Flag == FALSE)
    {
        bikelight_voBikeLightCoef(ass_stParaCong.uwLightVoltage);

        bikethrottle_voBikeThrottleCof();

        torsensor_voTorSensorCof();

        bikespeed_voBikeSpeedCof();

        bikespeed_voPICoef();

        cadence_voCadenceCof();

        display_voDisplayCoef();
                    
        ass_voAssitCoef();    

        scm_voSpdCtrMdCoef();

        switch_flg.SysCoef_Flag = TRUE;
    }

    /* System Coef Update */
    if (cp_stFlg.ParaAssistUpdateFinishFlg == TRUE && cp_stFlg.ParaUpdateFlg == FALSE)
    {
        if (FSM2nd_Run_state.state == Exit)
        {                     
            bikelight_voBikeLightCoef(ass_stParaCong.uwLightVoltage);
            
            torsensor_voTorSensorCof();

            ass_voAssitCoef();
            
            cp_stFlg.ParaAssistUpdateFinishFlg = FALSE;
        }
        else
        {}
    }
    else
    {}

    if (cp_stFlg.ParaMotorDriveUpdateFinishFlg == TRUE && cp_stFlg.ParaUpdateFlg == FALSE)
    {
        if (FSM2nd_Run_state.state == Exit)
        {
            if(cp_stFlg.TestParaInfoUpdateFlg == TRUE)
            {
                cp_stFlg.RunModelSelect = MC_UpcInfo.stTestParaInfo.RunModelSelect;
                cp_stFlg.ThetaGetModelSelect = MC_UpcInfo.stTestParaInfo.ThetaGetModelSelect;
                cp_stFlg.CurrentSampleModelSelect = MC_UpcInfo.stTestParaInfo.CurrentSampleModelSelect;
                cp_stFlg.RotateDirectionSelect = MC_UpcInfo.stTestParaInfo.RotateDirectionSelect;
                cp_stFlg.TestParaInfoUpdateFlg = FALSE;
            }

            scm_voSpdCtrMdCoef();
            alm_voCoef();
            cp_stFlg.ParaMotorDriveUpdateFinishFlg = FALSE;
        }
        else
        {}
    }
    else
    {}

    /* 2ND FSM Control */
    FSM_2nd_Main();
    FSM2nd_Run_state.Event_hook();

    /* System Run Flg Judge */
    if ((signal_state.Assist == 0 && signal_state.Sensor == 0) || (switch_flg.SysFault_Flag) || (power_stPowStateOut.powerstate == POWER_OFF) ||
        (switch_flg.SysCoef_Flag == FALSE) || (((cp_stFlg.ParaMotorDriveUpdateFinishFlg == TRUE) || ( cp_stFlg.ParaAssistUpdateFinishFlg == TRUE))&&FSM2nd_Run_state.state == Exit) )     
    {
        switch_flg.SysRun_Flag = FALSE;
    }
    else
    {
        switch_flg.SysRun_Flag = TRUE;
    }

}

void SysRdy_TbcUphook(void)
{}
void SysRdy_TbcDownhook(void)
{
    FSM2nd_Run_state.Tbcup_hook();
    FSM2nd_Run_state.Tbcdown_hook();
}
void SysRdy_Tbshook(void)
{
    FSM2nd_Run_state.Tbs_hook();
}

void SysFault_TbcUphook(void)
{
    /* Motor Fault Handle */
    alm_voHandleTBC(&alm_stIn);
}
void SysFault_hook(void)
{
    /* Bike Sensor Fault Handle */
    alm_voHandle1MS(&alm_stBikeIn);
}
void SysFault_TbcDownhook(void)
{}
void SysFault_Tbshook(void)
{}

void Switch_sys_FSM(const FSM_SYS_HOOK *in)
{
    void (*const function)(void) = switchfuction[FSM1st_Sys_state.state][in->state];
    function();
    FSM1st_Sys_state = *in;
}

void ReadytoRun(void)
{}