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

/**
 * @mainpage
 * Project Name:
 * Author:
 * Complier:
 * CPU_TYPE:
 * @section Project description:
 * -项目详细描述
 * @section function description:
 * -#功能描述
 * @section Usage description:
 * -#用法描述
 * @attention
 * -#注意事项
 */

#ifndef _MAIN_C_
#define _MAIN_C_
#endif

/************************************************************************
 Included File
*************************************************************************/
#include "syspar.h"
#include "user.h"
#include "TimeTask_Event.h"
#include "FSM_1st.h"
#include "FSM_2nd.h"
#include "can.h"
#include "cmdgennew.h"
#include "canAppl.h"
#include "flash_master.h"
#include "torquesensor.h"
#include "power.h"
#include "STLmain.h"
#include "api_rt.h"
#include "hwsetup.h"
#include "app.h"
#include "Temp.h"
#include "enviolo_can.h"
#include "giant_can.h"
#include "profiler.h"
/***************************
*********************************************
 Exported Functions:
************************************************************************/
/***************************************************************
 Function: main;
 Description:main function
 Call by:
 Input Variables: N/A
 Output/Return Variables: N/A
 Subroutine Call: N/A;
 Reference: N/A
****************************************************************/
int main(void) /* parasoft-suppress GJB5369-4_2_1_10 "mismatch" */
{
#ifndef RUN_ARCH_SIM
    SCB->VTOR = 0x08003000;

    DISABLE_IRQ; 
    /* MCU Core and GPIO configuration */
    hw_voHardwareSetup1();
    /* Peripheral configuration */
    hw_voHardwareSetup2();
    
    /* Api Init*/
    iRt_Init();

    /* Api App Init*/
    AppInit();
    
    /* Spi Position Comp */
    spi_voReadWriteSeneorReg();
    /* Error Log Read */
    flash_voErrorRead();
    /* MCU Self Test Init */
    stl_voRunTimeChecksInit();
    /* Watchdog 1s */
    hw_voIWDGInit(FWDGT_PSC_DIV32,1250);//1s
    /* Program load rate testing init */ 
    profiler_init();
    //Enviolo gear sensor init
    GearBox_Init();
    //ganir control data init
    giant_Init();
    /* Timer enable */
    hw_voTimEn();
    /* Interrupts of peripherals enable*/
    hw_voEnInt();
    /* Enable all interrupts */
    ENABLE_IRQ;
    
    /* Enter infinite loop */
    while (1)
    {
        PROFILER_BG();
        AppLoop();
    }
    
    return 0;
    
#endif
}
/***************************************************************
 Function: mn_voSoftwareInit;
 Description:software intial
 Call by:
 Input Variables: N/A
 Output/Return Variables: N/A
 Subroutine Call: N/A;
 Reference: N/A
****************************************************************/
void mn_voParaSet(void)
{
    /* Read system parameter*/  
    i2c_voSysparaReadFromEE(&i2c_stRXCRCOut);

    if (i2c_stRXCRCOut.blHistoryParaFltFlg == FALSE)
    {
        ass_stParaSet.uwAsssistSelectNum = I2C_uwHistoryParaRead[0];
        cp_stHistoryPara.uwOpenTimes = I2C_uwHistoryParaRead[1];
        cp_stHistoryPara.ulUsedTime = (((ULONG)I2C_uwHistoryParaRead[2]) << 16) + I2C_uwHistoryParaRead[3];
        cp_stHistoryPara.uwNTCTempMaxCe = I2C_uwHistoryParaRead[4];
        cp_stHistoryPara.uwNTCTempMinCe = I2C_uwHistoryParaRead[5];

        cp_stHistoryPara.uwAlamHOcurTimes = I2C_uwHistoryParaRead[6];
        cp_stHistoryPara.uwAlamSOcurTimes = I2C_uwHistoryParaRead[7];
        cp_stHistoryPara.uwAlamOHeatTimes = I2C_uwHistoryParaRead[8];
        cp_stHistoryPara.uwAlamRotorLockTimes = I2C_uwHistoryParaRead[9];
        cp_stHistoryPara.uwAlamPhsLossTimes = I2C_uwHistoryParaRead[10];
        cp_stHistoryPara.uwAlamOVolTimes = I2C_uwHistoryParaRead[11];
        cp_stHistoryPara.uwAlamUVolTimes = I2C_uwHistoryParaRead[12];
        cp_stHistoryPara.uwAlamComOTimeTimes = I2C_uwHistoryParaRead[13];

        cp_stHistoryPara.uwG1AvgPwrConsumption = I2C_uwHistoryParaRead[14];
        cp_stHistoryPara.uwG2AvgPwrConsumption = I2C_uwHistoryParaRead[15];
        cp_stHistoryPara.uwG3AvgPwrConsumption = I2C_uwHistoryParaRead[16];
        cp_stHistoryPara.uwG4AvgPwrConsumption = I2C_uwHistoryParaRead[17];
        cp_stHistoryPara.uwG5AvgPwrConsumption = I2C_uwHistoryParaRead[18];

        cp_stHistoryPara.ulODOTrip = (((ULONG)I2C_uwHistoryParaRead[19]) << 16) + I2C_uwHistoryParaRead[20];
        cp_stHistoryPara.ulODOTime = (((ULONG)I2C_uwHistoryParaRead[21]) << 16) + I2C_uwHistoryParaRead[22];
        cp_stHistoryPara.ulTripSum = (((ULONG)I2C_uwHistoryParaRead[23]) << 16) + I2C_uwHistoryParaRead[24];
        cp_stHistoryPara.ulTripSumTime = (((ULONG)I2C_uwHistoryParaRead[25]) << 16) + I2C_uwHistoryParaRead[26];

        cp_stHistoryPara.uwTorSensorAlamTimes = I2C_uwHistoryParaRead[27];
        cp_stHistoryPara.uwCadSensorAlamTimes = I2C_uwHistoryParaRead[28];
        cp_stHistoryPara.uwBikeSpdSensorAlamTimes = I2C_uwHistoryParaRead[29];
        cp_stHistoryPara.uwPosSensorAlamTimes = I2C_uwHistoryParaRead[30];
        
        cp_stHistoryPara.ulRealODOTrip = (((ULONG)I2C_uwHistoryParaRead[31]) << 16) + I2C_uwHistoryParaRead[32];
        cp_stHistoryPara.ulRealODOTime = (((ULONG)I2C_uwHistoryParaRead[33]) << 16) + I2C_uwHistoryParaRead[34];
    }
    else
    {}
    
    // peripheral Para Set
    cadence_stFreGetCof.uwNumbersPulses = CADENCE_NUMBERS_PULSES;
    bikespeed_stFreGetCof.uwNumbersPulses = BIKESPEED_NUMBERS_PULSES;
    torsensor_stTorSensorCof.uwMaxSensorTorquePu = ((ULONG)TORQUE_MAX_RANGE << 14) / TORQUEBASE; // Q14

    /////////////////////////////////
    if (cp_stFlg.ParaUseEEFlg == TRUE)
    {
        if (i2c_stRXCRCOut.ReadFinishFlg == TRUE)
        {
            if (i2c_stRXCRCOut.blMotorParaFltFlg == FALSE)
            {
                cp_stMotorPara.swMotrPolePairs = (SWORD)I2C_uwMotorParaRead[0];
                cp_stMotorPara.swRsOhm = (SWORD)I2C_uwMotorParaRead[1];
                cp_stMotorPara.swLdmH = (SWORD)I2C_uwMotorParaRead[2];
                cp_stMotorPara.swLqmH = (SWORD)I2C_uwMotorParaRead[3];
                cp_stMotorPara.swFluxWb = (SWORD)I2C_uwMotorParaRead[4];
                cp_stMotorPara.swIdMaxA = (SWORD)I2C_uwMotorParaRead[5];
                cp_stMotorPara.swIdMinA = (SWORD)I2C_uwMotorParaRead[6];
                cp_stMotorPara.swRSpeedRpm = (SWORD)I2C_uwMotorParaRead[7];
                cp_stMotorPara.swRPwrWt = (SWORD)I2C_uwMotorParaRead[8];
                cp_stMotorPara.swRIarmsA = (SWORD)I2C_uwMotorParaRead[9];
                cp_stMotorPara.swRUdcV = (SWORD)I2C_uwMotorParaRead[10];
                cp_stMotorPara.swJD = (SWORD)I2C_uwMotorParaRead[11];
                cp_stMotorPara.swTorMax = (SWORD)I2C_uwMotorParaRead[12];
            }
            else
            {}
            if (i2c_stRXCRCOut.blBikeParaFltFlg == FALSE)
            {
                ass_stParaCong.uwWheelPerimeter = I2C_uwBikeParaRead[0];
                ass_stParaCong.uwMechRationMotor = I2C_uwBikeParaRead[1];
                ass_stParaCong.uwThrottleMaxSpdKmH = I2C_uwBikeParaRead[2];
                ass_stParaCong.uwCartSpdKmH = I2C_uwBikeParaRead[3];
                ass_stParaCong.uwNmFrontChainring = I2C_uwBikeParaRead[4];
                ass_stParaCong.uwNmBackChainring = I2C_uwBikeParaRead[5];
                ass_stParaCong.uwAssistSelect1 = I2C_uwBikeParaRead[6];
                ass_stParaCong.uwAssistSelect2 = I2C_uwBikeParaRead[7];
                ass_stParaCong.uwLightVoltage = I2C_uwBikeParaRead[8];
                ass_stParaCong.swDeltPerimeter = (SWORD)I2C_uwBikeParaRead[9];
                ass_stParaCong.uwStartMode = I2C_uwBikeParaRead[10];
                ass_stParaCong.uwAutoPowerOffTime = I2C_uwBikeParaRead[11];
                ass_stParaCong.uwThrottleSmooth = I2C_uwBikeParaRead[12];
            }
            else
            {}
            if (i2c_stRXCRCOut.blMControlParaFltFlg == FALSE)
            {
                cp_stFlg.ParaFirstSetFlg = I2C_uwMControlRead[0];
                cp_stFlg.SpiOffsetFirstSetFlg = I2C_uwMControlRead[1];
                spi_stResolverOut.swSpiThetaOffsetOrignPu = (SWORD)I2C_uwMControlRead[2];
                spi_stResolverOut.swSpiThetaOffsetPu = (SWORD)I2C_uwMControlRead[3];
                cp_stMotorPara.swIpeakMaxA = (SWORD)I2C_uwMControlRead[4];
                cp_stControlPara.swAlmOverCurrentVal = (SWORD)I2C_uwMControlRead[5];
                cp_stControlPara.swAlmOverVolVal1 = (SWORD)I2C_uwMControlRead[6];
                cp_stControlPara.swAlmUnderVolVal1 = (SWORD)I2C_uwMControlRead[7];
                cp_stControlPara.swAlmOverSpdVal = (SWORD)I2C_uwMControlRead[8];
                cp_stControlPara.swAlmOverHeatCeVal = (SWORD)I2C_uwMControlRead[9];
                cp_stControlPara.swAlmRecOHeatVal = (SWORD)I2C_uwMControlRead[10];
                cp_stControlPara.swAlmPwrLimitStartTempVal = (SWORD)I2C_uwMControlRead[11];
//                cp_stControlPara.swAlmMotorOverHeatCeVal = (SWORD)I2C_uwMControlRead[12];
//                cp_stControlPara.swAlmMotorRecOHeatVal = (SWORD)I2C_uwMControlRead[13];
//                cp_stControlPara.swAlmPwrLimitMotorStartTempVal = (SWORD)I2C_uwMControlRead[14];
                ass_stParaCong.uwControlFunEN = I2C_uwMControlRead[15];
                ass_stParaCong.uwThrottleGearEN = I2C_uwMControlRead[16];
                
                cp_stControlPara.swAlmRecOVVal = (SWORD)(cp_stControlPara.swAlmOverVolVal1 - ALM_VLT_REC_ERRVAL);//updata recover data
                cp_stControlPara.swAlmRecUVVal = (SWORD)(cp_stControlPara.swAlmUnderVolVal1 + ALM_VLT_REC_ERRVAL);
                cp_stControlPara.swCvbConstantVolBrakeV = (SWORD)(cp_stControlPara.swAlmOverVolVal1 - CVB_CONSTANT_VOL_BRAKE_ERRV);
            }
            else
            {
                cp_stFlg.RunPermitFlg = FALSE;
            }
            if (i2c_stRXCRCOut.blSensorParaFltFlg == FALSE)
            {
                torsensor_stTorSensorCof.uwTorqueOffsetOrign = I2C_uwSensorRead[0];
                torsensor_stTorSensorCof.uwTorqueOffsetNow1 = I2C_uwSensorRead[1];
                torsensor_stTorSensorCof.uwTorqueOffsetNow2 = I2C_uwSensorRead[2];
                torsensor_stTorSensorCof.uwTorqueOffsetNow3 = I2C_uwSensorRead[3];
                torsensor_stTorSensorCof.uwTorqueOffsetNow4 = I2C_uwSensorRead[4];
                torsensor_stTorSensorCof.uwMaxSensorTorquePu = I2C_uwSensorRead[5];
                torsensor_stTorSensorCof.uwBikeTorStep1RealNm = I2C_uwSensorRead[6];
                torsensor_stTorSensorCof.uwBikeTorStep1ADC = I2C_uwSensorRead[7];
                torsensor_stTorSensorCof.uwBikeTorStep2RealNm = I2C_uwSensorRead[8];
                torsensor_stTorSensorCof.uwBikeTorStep2ADC = I2C_uwSensorRead[9];
                torsensor_stTorSensorCof.uwBikeTorStep3RealNm = I2C_uwSensorRead[10];
                torsensor_stTorSensorCof.uwBikeTorStep3ADC = I2C_uwSensorRead[11];
                torsensor_stTorSensorCof.uwBikeTorStep4RealNm = I2C_uwSensorRead[12];
                torsensor_stTorSensorCof.uwBikeTorStep4ADC = I2C_uwSensorRead[13];
                cadence_stFreGetCof.uwNumbersPulses = I2C_uwSensorRead[14];
                bikespeed_stFreGetCof.uwNumbersPulses = I2C_uwSensorRead[15];
            }
            else
            {
                cp_stFlg.RunPermitFlg = FALSE;
            }

            if (i2c_stRXCRCOut.blAssistParaFltFlg == FALSE)
            {
                ass_stParaSet.uwStartupCoef = I2C_uwAssistParaRead[0];
                ass_stParaSet.uwStartupCruiseCoef = I2C_uwAssistParaRead[1];
                ass_stParaSet.uwAssistStartNm = I2C_uwAssistParaRead[2];
                ass_stParaSet.uwAssistStopNm = I2C_uwAssistParaRead[3];
                ass_stParaSet.uwStartUpGainStep = I2C_uwAssistParaRead[4];
                ass_stParaSet.uwStartUpCadNm = I2C_uwAssistParaRead[5];
                ass_stParaSet.uwTorLPFCadNm = I2C_uwAssistParaRead[6];
                ass_stParaSet.uwSpeedAssistSpdRpm = I2C_uwAssistParaRead[7];
                ass_stParaSet.uwSpeedAssistIMaxA = I2C_uwAssistParaRead[8];
                ass_stParaSet.uwAssistLimitBikeSpdStart = I2C_uwAssistParaRead[9];
                ass_stParaSet.uwAssistLimitBikeSpdStop = I2C_uwAssistParaRead[10];
                ass_stParaSet.uwCadenceWeight = I2C_uwAssistParaRead[11];
//                ass_stParaSet.uwTorWeight = Q12_1 - ass_stParaSet.uwCadenceWeight;
            }
            else
            {}
            
            if (i2c_stRXCRCOut.blRideParaFltFlg == FALSE)
            {
                for(int i=0;i<5;i++)
                {
                    ass_stCalCoef.ucAssistRatioGain[i] = (UBYTE)(I2C_uwRideParaRead[i]>>8);
                    ass_stCalCoef.ucAssistAccelerationGain[i] = (UBYTE)(I2C_uwRideParaRead[i]);
                    ass_stCalCoef.ucMaxCurrentGain[i] = (UBYTE)(I2C_uwRideParaRead[i+5]>>8);
                    ass_stCalCoef.ucMaxTorqueGain[i] = (UBYTE)(I2C_uwRideParaRead[i+5]);
                }
            }
            else
            {
            }
            if(ass_stCalCoef.ucAssistRatioGain[0] == 0)
            {
                for(int i=0;i<5;i++)
                {
                    ass_stCalCoef.ucAssistRatioGain[i] = 100;
                    ass_stCalCoef.ucAssistAccelerationGain[i] = 100;
                    ass_stCalCoef.ucMaxCurrentGain[i] = 100;
                    ass_stCalCoef.ucMaxTorqueGain[i] = 100;
                }
            }
            
            if (i2c_stRXCRCOut.blBikePara2FltFlg == FALSE)
            {
                ass_stParaCong.uwNoneOBCEnable = I2C_uwBikePara2Read[0];
                ass_stParaCong.uwRearLightCycle = I2C_uwBikePara2Read[1];
                ass_stParaCong.uwRearLightDuty = I2C_uwBikePara2Read[2];
                ass_stParaCong.swDeltaBikeSpeedLimit = (SWORD) I2C_uwBikePara2Read[3];
            }
            else
            {
            }
        }
        cp_stFlg.ParaUseEEFinishFlg = TRUE;
    }
    else
    {}
    
    if (i2c_stRXCRCOut.blGearBoxParaFltFlg == FALSE)
    {
        GearBox_OBC_SetParams.GearNum = I2C_uwGearBoxParaRead[0];
        GearBox_OBC_SetParams.CadenceMin = I2C_uwGearBoxParaRead[1];
        GearBox_OBC_SetParams.CadenceMax = I2C_uwGearBoxParaRead[2];
    }
    else
    {}
}

/***************************************************************
 Function: mn_voParaUpdate;
 Description:update pra from upper PC
 Call by:
 Input Variables: N/A
 Output/Return Variables: N/A
 Subroutine Call: N/A;
 Reference: N/A
****************************************************************/
void mn_voParaUpdate(void)
{
    if (cp_stFlg.ParaMInfoUpdateFlg == TRUE)
    {
        cp_stMotorPara.swMotrPolePairs = (SWORD)MC_UpcInfo.stMotorInfo.uwPolePairs;
        cp_stMotorPara.swRsOhm = (SWORD)MC_UpcInfo.stMotorInfo.uwRsmOhm;
        cp_stMotorPara.swLdmH = (SWORD)MC_UpcInfo.stMotorInfo.uwLduH;
        cp_stMotorPara.swLqmH = (SWORD)MC_UpcInfo.stMotorInfo.uwLquH;
        cp_stMotorPara.swFluxWb = (SWORD)MC_UpcInfo.stMotorInfo.uwFluxmWb;
        cp_stMotorPara.swIdMaxA = (SWORD)MC_UpcInfo.stMotorInfo.uwIdMaxA;
        cp_stMotorPara.swIdMinA = (SWORD)MC_UpcInfo.stMotorInfo.uwIdMinA;
        cp_stMotorPara.swRSpeedRpm = (SWORD)MC_UpcInfo.stMotorInfo.uwRSpdRpm;
        cp_stMotorPara.swRPwrWt = (SWORD)MC_UpcInfo.stMotorInfo.uwRPwrWt;
        cp_stMotorPara.swRIarmsA = (SWORD)MC_UpcInfo.stMotorInfo.uwRCurA;
        cp_stMotorPara.swRUdcV = (SWORD)MC_UpcInfo.stMotorInfo.uwRVolV;
        cp_stMotorPara.swJD = (SWORD)MC_UpcInfo.stMotorInfo.uwJD;
        cp_stMotorPara.swTorMax = (SWORD)MC_UpcInfo.stMotorInfo.uwTorMaxNm;

        cp_stFlg.ParaMotorDriveUpdateFinishFlg = TRUE;
        cp_stFlg.ParaMInfoUpdateFlg = FALSE;
    }

    if (cp_stFlg.ParaBikeInfoUpdateFlg == TRUE)
    {
        ass_stParaCong.uwWheelPerimeter = MC_UpcInfo.stBikeInfo.uwWheelPerimeter;
        ass_stParaCong.uwMechRationMotor = MC_UpcInfo.stBikeInfo.uwMechRationMotor;
        ass_stParaCong.uwThrottleMaxSpdKmH = MC_UpcInfo.stBikeInfo.uwThrottleMaxSpdKmH;
        ass_stParaCong.uwCartSpdKmH = MC_UpcInfo.stBikeInfo.uwCartSpdKmH;
        ass_stParaCong.uwNmFrontChainring = MC_UpcInfo.stBikeInfo.uwNmFrontChainring;
        ass_stParaCong.uwNmBackChainring = MC_UpcInfo.stBikeInfo.uwNmBackChainring;
        ass_stParaCong.uwAssistSelect1 = MC_UpcInfo.stBikeInfo.uwAssistSelect1;
        ass_stParaCong.uwAssistSelect2 = MC_UpcInfo.stBikeInfo.uwAssistSelect2;
        ass_stParaCong.uwLightVoltage = MC_UpcInfo.stBikeInfo.uwLightVoltage;
        ass_stParaCong.swDeltPerimeter = MC_UpcInfo.stBikeInfo.swWheelSizeAdjust;
        ass_stParaCong.uwStartMode = MC_UpcInfo.stBikeInfo.uwStartMode;
        ass_stParaCong.uwAutoPowerOffTime = MC_UpcInfo.stBikeInfo.uwAutoPowerOffTime;
        ass_stParaCong.uwThrottleSmooth = MC_UpcInfo.stBikeInfo.uwThrottleSmooth;

        cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
        cp_stFlg.ParaBikeInfoUpdateFlg = FALSE;
    }

    if (cp_stFlg.ParaMCInfoUpdateFlg == TRUE)
    {
        cp_stFlg.ParaFirstSetFlg = MC_UpcInfo.stTestParaInfo.uwEEFirstDefaultSetFlg;
        cp_stFlg.SpiOffsetFirstSetFlg = MC_UpcInfo.stTestParaInfo.uwSPIOffsetFirstSetFlg;
        spi_stResolverOut.swSpiThetaOffsetOrignPu = MC_UpcInfo.stMContorlInfo.uwSPIPosOffsetOrigin;
        spi_stResolverOut.swSpiThetaOffsetPu = MC_UpcInfo.stMContorlInfo.uwSPIPosOffsetNow;
        cp_stMotorPara.swIpeakMaxA = (SWORD)MC_UpcInfo.stMContorlInfo.uwIPeakMaxA;
        cp_stControlPara.swAlmOverCurrentVal = (SWORD)MC_UpcInfo.stMContorlInfo.uwAlamOCurA;
        cp_stControlPara.swAlmOverVolVal1 = (SWORD)MC_UpcInfo.stMContorlInfo.uwAlamOVolV;
        cp_stControlPara.swAlmUnderVolVal1 = (SWORD)MC_UpcInfo.stMContorlInfo.uwAlamUVolV;
        cp_stControlPara.swAlmOverSpdVal = (SWORD)MC_UpcInfo.stMContorlInfo.uwAlamOverSpdRpm;
        cp_stControlPara.swAlmOverHeatCeVal = (SWORD)MC_UpcInfo.stMContorlInfo.uwAlamOverHeatCe;
        cp_stControlPara.swAlmRecOHeatVal = (SWORD)MC_UpcInfo.stMContorlInfo.uwAlamRecHeatCe;
        cp_stControlPara.swAlmPwrLimitStartTempVal = (SWORD)MC_UpcInfo.stMContorlInfo.uwPwrLimitStartCe;
//        cp_stControlPara.swAlmMotorOverHeatCeVal = MC_UpcInfo.stMContorlInfo.uwAlamMotorOverHeatCe;
//        cp_stControlPara.swAlmMotorRecOHeatVal = MC_UpcInfo.stMContorlInfo.uwAlamMotorRecHeatCe;
//        cp_stControlPara.swAlmPwrLimitMotorStartTempVal = MC_UpcInfo.stMContorlInfo.uwPwrLimitMotorStartCe;
        ass_stParaCong.uwControlFunEN = MC_UpcInfo.stMContorlInfo.uwControlFunEN;
        ass_stParaCong.uwThrottleGearEN = MC_UpcInfo.stMContorlInfo.uwThrottleGearEN;
        
        cp_stControlPara.swAlmRecOVVal = (SWORD)(cp_stControlPara.swAlmOverVolVal1 - ALM_VLT_REC_ERRVAL);
        cp_stControlPara.swAlmRecUVVal = (SWORD)(cp_stControlPara.swAlmUnderVolVal1 + ALM_VLT_REC_ERRVAL);
        cp_stControlPara.swCvbConstantVolBrakeV = (SWORD)(cp_stControlPara.swAlmOverVolVal1 - CVB_CONSTANT_VOL_BRAKE_ERRV);

        cp_stFlg.ParaMotorDriveUpdateFinishFlg = TRUE;
        cp_stFlg.ParaMCInfoUpdateFlg = FALSE;
    }

    if (cp_stFlg.ParaSensorInfoUpdateFlg == TRUE)
    {
        torsensor_stTorSensorCof.uwTorqueOffsetOrign = MC_UpcInfo.stSensorInfo.uwTorSensorOffsetOrigin;
        torsensor_stTorSensorCof.uwMaxSensorTorquePu = MC_UpcInfo.stSensorInfo.uwBikeTorMaxNm;
        torsensor_stTorSensorCof.uwBikeTorStep1RealNm = MC_UpcInfo.stSensorInfo.uwBikeTor1StepRealNm;
        torsensor_stTorSensorCof.uwBikeTorStep1ADC = MC_UpcInfo.stSensorInfo.uwBikeTor1StepADC;
        torsensor_stTorSensorCof.uwBikeTorStep2RealNm = MC_UpcInfo.stSensorInfo.uwBikeTor2StepRealNm;
        torsensor_stTorSensorCof.uwBikeTorStep2ADC = MC_UpcInfo.stSensorInfo.uwBikeTor2StepADC;
        torsensor_stTorSensorCof.uwBikeTorStep3RealNm = MC_UpcInfo.stSensorInfo.uwBikeTor3StepRealNm;
        torsensor_stTorSensorCof.uwBikeTorStep3ADC = MC_UpcInfo.stSensorInfo.uwBikeTor3StepADC;
        torsensor_stTorSensorCof.uwBikeTorStep4RealNm = MC_UpcInfo.stSensorInfo.uwBikeTor4StepRealNm;
        torsensor_stTorSensorCof.uwBikeTorStep4ADC = MC_UpcInfo.stSensorInfo.uwBikeTor4StepADC;
        cadence_stFreGetCof.uwNumbersPulses = MC_UpcInfo.stSensorInfo.uwCadSensorPulseNm;
        bikespeed_stFreGetCof.uwNumbersPulses = MC_UpcInfo.stSensorInfo.uwBikeSpdSensorPulseNm;

        cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
        cp_stFlg.ParaSensorInfoUpdateFlg = FALSE;
    }

    if (cp_stFlg.ParaAInfoUpdateFlg == TRUE)
    {
        ass_stParaSet.uwStartupCoef = MC_UpcInfo.stAssistInfo.swStartupGain;
        ass_stParaSet.uwStartupCruiseCoef = MC_UpcInfo.stAssistInfo.swStartcruiseGain;
        ass_stParaSet.uwAssistStartNm = MC_UpcInfo.stAssistInfo.uwAssistStartNm;
        ass_stParaSet.uwAssistStopNm = MC_UpcInfo.stAssistInfo.uwAssistStopNm;
        ass_stParaSet.uwStartUpGainStep = MC_UpcInfo.stAssistInfo.uwStartUpGainStep;
        ass_stParaSet.uwStartUpCadNm = MC_UpcInfo.stAssistInfo.uwStartUpCadNm;
        ass_stParaSet.uwTorLPFCadNm = MC_UpcInfo.stAssistInfo.uwTorLPFCadNm;
        ass_stParaSet.uwSpeedAssistSpdRpm = MC_UpcInfo.stAssistInfo.uwSpeedAssistSpdRpm;
        ass_stParaSet.uwSpeedAssistIMaxA = MC_UpcInfo.stAssistInfo.uwSpeedAssistIMaxA;
        ass_stParaSet.uwAssistLimitBikeSpdStart = MC_UpcInfo.stAssistInfo.uwAssistLimitBikeSpdStart;
        ass_stParaSet.uwAssistLimitBikeSpdStop = MC_UpcInfo.stAssistInfo.uwAssistLimitBikeSpdStop;
        ass_stParaSet.uwCadenceWeight = MC_UpcInfo.stAssistInfo.uwCadenceAssistWeight;
        //ass_stParaSet.uwTorWeight = Q12_1 - ass_stParaSet.uwCadenceWeight;

        cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
        cp_stFlg.ParaAInfoUpdateFlg = FALSE;
    }

    if(cp_stFlg.TestParaInfoUpdateFlg == TRUE)
    {
        cp_stControlPara.swAlignCurAp = (SWORD)MC_UpcInfo.stTestParaInfo.uwInitPosCurAmp;
        cp_stControlPara.swDragVolAp = (SWORD)MC_UpcInfo.stTestParaInfo.uwVFControlVolAmp;
        cp_stControlPara.swDragCurAp = (SWORD)MC_UpcInfo.stTestParaInfo.uwIFControlCurAmp;
        cp_stControlPara.swDragSpdHz = (SWORD)MC_UpcInfo.stTestParaInfo.uwVFIFTargetFreHz;

        cp_stControlPara.swSpeedAccRate = (SWORD)MC_UpcInfo.stTestParaInfo.uwSpeedLoopAccRate;
        cp_stControlPara.swSpeedDccRate = (SWORD)MC_UpcInfo.stTestParaInfo.uwSpeedLoopDecRate;
        cp_stControlPara.swAsrPIBandwidth = (SWORD)MC_UpcInfo.stTestParaInfo.uwSpeedLoopBandWidthHz;
        cp_stControlPara.swAsrPIM = (SWORD)MC_UpcInfo.stTestParaInfo.uwSpeedLoopCoefM;

        cp_stControlPara.swAcrPIBandwidth = (SWORD)MC_UpcInfo.stTestParaInfo.uwCuerrentLoopBandWidthHz;
        cp_stControlPara.swAcrRaCoef = (SWORD)MC_UpcInfo.stTestParaInfo.uwCurrentLoopCoefM;

        cp_stControlPara.swObsFluxPICrossfreHz = (SWORD)MC_UpcInfo.stTestParaInfo.uwFluxObsBandWidthHz;
        cp_stControlPara.swObsFluxPIDampratio = (SWORD)MC_UpcInfo.stTestParaInfo.uwFluxObsCoefM;
        cp_stControlPara.swObsSpdPLLBandWidthHz = (SWORD)MC_UpcInfo.stTestParaInfo.uwThetaObsPLLBandWidthHz;
        cp_stControlPara.swObsSpdPLLM = (SWORD)MC_UpcInfo.stTestParaInfo.uwThetaObsPLLCoefM;

        cp_stMotorPara.swJD = (SWORD)MC_UpcInfo.stTestParaInfo.uwJm;
        cp_stControlPara.swPWMMaxDuty = (SWORD)MC_UpcInfo.stTestParaInfo.uwPWMMaxDuty;
        cp_stControlPara.swPWM7to5Duty = (SWORD)MC_UpcInfo.stTestParaInfo.uwPWM7to5Duty;
        cp_stControlPara.swPwrLimitValWt = (SWORD)MC_UpcInfo.stTestParaInfo.uwPwrLimit;
        cp_stControlPara.swPwrLimitErrWt = (SWORD)MC_UpcInfo.stTestParaInfo.uwPwrLimitError;
        cp_stControlPara.swPwrLimitKpPu = (SWORD)MC_UpcInfo.stTestParaInfo.uwPwrLimitKp;
        cp_stControlPara.swPwrLimitKiPu = (SWORD)MC_UpcInfo.stTestParaInfo.uwPwrLimitKi;

        cp_stFlg.ParaMotorDriveUpdateFinishFlg = TRUE;
        // cp_stFlg.TestParaInfoUpdateFlg = FALSE;
    }
    
    if (cp_stFlg.ParaRideInfoUpdateFlg == TRUE)
    {
        ass_stCalCoef.ucAssistRatioGain[0] = MC_UpcInfo.stRideParaInfo.ucAssistRatioGain1;
        ass_stCalCoef.ucAssistRatioGain[1] = MC_UpcInfo.stRideParaInfo.ucAssistRatioGain2;
        ass_stCalCoef.ucAssistRatioGain[2] = MC_UpcInfo.stRideParaInfo.ucAssistRatioGain3;
        ass_stCalCoef.ucAssistRatioGain[3] = MC_UpcInfo.stRideParaInfo.ucAssistRatioGain4;
        ass_stCalCoef.ucAssistRatioGain[4] = MC_UpcInfo.stRideParaInfo.ucAssistRatioGain5;
        
        ass_stCalCoef.ucAssistAccelerationGain[0] = MC_UpcInfo.stRideParaInfo.ucAssistAccelerationGain1;
        ass_stCalCoef.ucAssistAccelerationGain[1] = MC_UpcInfo.stRideParaInfo.ucAssistAccelerationGain2;
        ass_stCalCoef.ucAssistAccelerationGain[2] = MC_UpcInfo.stRideParaInfo.ucAssistAccelerationGain3;
        ass_stCalCoef.ucAssistAccelerationGain[3] = MC_UpcInfo.stRideParaInfo.ucAssistAccelerationGain4;
        ass_stCalCoef.ucAssistAccelerationGain[4] = MC_UpcInfo.stRideParaInfo.ucAssistAccelerationGain5;
        
        ass_stCalCoef.ucMaxCurrentGain[0] = MC_UpcInfo.stRideParaInfo.ucMaxCurrentGain1;
        ass_stCalCoef.ucMaxCurrentGain[1] = MC_UpcInfo.stRideParaInfo.ucMaxCurrentGain2;
        ass_stCalCoef.ucMaxCurrentGain[2] = MC_UpcInfo.stRideParaInfo.ucMaxCurrentGain3;
        ass_stCalCoef.ucMaxCurrentGain[3] = MC_UpcInfo.stRideParaInfo.ucMaxCurrentGain4;
        ass_stCalCoef.ucMaxCurrentGain[4] = MC_UpcInfo.stRideParaInfo.ucMaxCurrentGain5;
        
        ass_stCalCoef.ucMaxTorqueGain[0] = MC_UpcInfo.stRideParaInfo.ucMaxTorqueGain1;
        ass_stCalCoef.ucMaxTorqueGain[1] = MC_UpcInfo.stRideParaInfo.ucMaxTorqueGain2;
        ass_stCalCoef.ucMaxTorqueGain[2] = MC_UpcInfo.stRideParaInfo.ucMaxTorqueGain3;
        ass_stCalCoef.ucMaxTorqueGain[3] = MC_UpcInfo.stRideParaInfo.ucMaxTorqueGain4;
        ass_stCalCoef.ucMaxTorqueGain[4] = MC_UpcInfo.stRideParaInfo.ucMaxTorqueGain5;

        cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
        cp_stFlg.ParaRideInfoUpdateFlg = FALSE;
    }
    
    if (cp_stFlg.ParaBikeInfo2UpdateFlg == TRUE)
    {
        ass_stParaCong.uwNoneOBCEnable = MC_UpcInfo.stBikeInfo2.uwNoneOBCEnable;
        ass_stParaCong.uwRearLightCycle = MC_UpcInfo.stBikeInfo2.uwRearLightCycle;
        ass_stParaCong.uwRearLightDuty = MC_UpcInfo.stBikeInfo2.uwRearLightDuty;
        ass_stParaCong.swDeltaBikeSpeedLimit = MC_UpcInfo.stBikeInfo2.swDeltaBikeSpeedLimit;

        cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
        cp_stFlg.ParaBikeInfo2UpdateFlg = FALSE;
    }
}
/***************************************************************
 Function: mn_voSoftwareInit;
 Description:software intial
 Call by:
 Input Variables: N/A
 Output/Return Variables: N/A
 Subroutine Call: N/A;
 Reference: N/A
****************************************************************/
void mn_voEEUperParaUpdate(void)
{
    if (MC_UpcInfo.stMotorInfo.uwSaveFlg == TRUE)
    {
        Syspara2.stMotorPara.uwPolePairs.uwReal = (UWORD)cp_stMotorPara.swMotrPolePairs;
        Syspara2.stMotorPara.uwRsmOhm.uwReal = (UWORD)cp_stMotorPara.swRsOhm;
        Syspara2.stMotorPara.uwLduH.uwReal = (UWORD)cp_stMotorPara.swLdmH;
        Syspara2.stMotorPara.uwLquH.uwReal = (UWORD)cp_stMotorPara.swLqmH;
        Syspara2.stMotorPara.uwFluxmWb.uwReal = (UWORD)cp_stMotorPara.swFluxWb;
        Syspara2.stMotorPara.uwIdMaxA.uwReal = (UWORD)cp_stMotorPara.swIdMaxA;
        Syspara2.stMotorPara.uwIdMinA.uwReal = (UWORD)cp_stMotorPara.swIdMinA;
        Syspara2.stMotorPara.uwRSpdRpm.uwReal = (UWORD)cp_stMotorPara.swRSpeedRpm;
        Syspara2.stMotorPara.uwRPwrWt.uwReal = (UWORD)cp_stMotorPara.swRPwrWt;
        Syspara2.stMotorPara.uwRCurA.uwReal = (UWORD)cp_stMotorPara.swRIarmsA;
        Syspara2.stMotorPara.uwRVolV.uwReal = (UWORD)cp_stMotorPara.swRUdcV;
        Syspara2.stMotorPara.uwJD.uwReal = (UWORD)cp_stMotorPara.swJD;
        Syspara2.stMotorPara.uwTorMaxNm.uwReal = (UWORD)cp_stMotorPara.swTorMax;
    }
    Syspara2.stBikePara.swDeltPerimeter.swReal = ass_stParaCong.swDeltPerimeter;
    if (MC_UpcInfo.stBikeInfo.uwSaveFlg == TRUE)
    {
        Syspara2.stBikePara.uwWheelPerimeter.uwReal = ass_stParaCong.uwWheelPerimeter;
        Syspara2.stBikePara.uwMechRationMotor.uwReal = ass_stParaCong.uwMechRationMotor;
        Syspara2.stBikePara.uwThrottleMaxSpdKmH.uwReal = ass_stParaCong.uwThrottleMaxSpdKmH;
        Syspara2.stBikePara.uwCartSpdKmH.uwReal = ass_stParaCong.uwCartSpdKmH;
        Syspara2.stBikePara.uwNmFrontChainring.uwReal = ass_stParaCong.uwNmFrontChainring;
        Syspara2.stBikePara.uwNmBackChainring.uwReal = ass_stParaCong.uwNmBackChainring;
        Syspara2.stBikePara.uwAssistSelect1.uwReal = ass_stParaCong.uwAssistSelect1;
        Syspara2.stBikePara.uwAssistSelect2.uwReal = ass_stParaCong.uwAssistSelect2;
        Syspara2.stBikePara.uwLightVoltage.uwReal = ass_stParaCong.uwLightVoltage;
        Syspara2.stBikePara.swDeltPerimeter.swReal = ass_stParaCong.swDeltPerimeter;
        Syspara2.stBikePara.uwStartMode.uwReal = ass_stParaCong.uwStartMode;
        Syspara2.stBikePara.uwAutoPowerOffTime.uwReal = ass_stParaCong.uwAutoPowerOffTime;
        Syspara2.stBikePara.uwThrottleSmooth.uwReal = ass_stParaCong.uwThrottleSmooth;
    }
    if (MC_UpcInfo.stMContorlInfo.uwSaveFlg == TRUE)
    {
        Syspara2.stMControlPara.ParaFirstSetFlg.uwReal = cp_stFlg.ParaFirstSetFlg;
        Syspara2.stMControlPara.SpiOffsetFirstSetFlg.uwReal = cp_stFlg.SpiOffsetFirstSetFlg;
        Syspara2.stMControlPara.uwSPIPosOffsetOrigin.uwReal = spi_stResolverOut.swSpiThetaOffsetOrignPu;
        Syspara2.stMControlPara.uwSPIPosOffsetNow.uwReal = spi_stResolverOut.swSpiThetaOffsetPu;
        Syspara2.stMControlPara.uwIPeakMaxA.uwReal = (UWORD)cp_stMotorPara.swIpeakMaxA;
        Syspara2.stMControlPara.uwAlamOCurA.uwReal = (UWORD)cp_stControlPara.swAlmOverCurrentVal;
        Syspara2.stMControlPara.uwAlamOVolV.uwReal = (UWORD)cp_stControlPara.swAlmOverVolVal1;
        Syspara2.stMControlPara.uwAlamUVolV.uwReal = (UWORD)cp_stControlPara.swAlmUnderVolVal1;
        Syspara2.stMControlPara.uwAlamOverSpdRpm.uwReal = (UWORD)cp_stControlPara.swAlmOverSpdVal;
        Syspara2.stMControlPara.uwAlamOverHeatCe.uwReal = (UWORD)cp_stControlPara.swAlmOverHeatCeVal;
        Syspara2.stMControlPara.uwAlamRecHeatCe.uwReal = (UWORD)cp_stControlPara.swAlmRecOHeatVal;
        Syspara2.stMControlPara.uwPwrLimitStartCe.uwReal = (UWORD)cp_stControlPara.swAlmPwrLimitStartTempVal;
//        Syspara2.stMControlPara.uwAlamMotorOverHeatCe.uwReal = (UWORD)cp_stControlPara.swAlmMotorOverHeatCeVal;
//        Syspara2.stMControlPara.uwAlamMotorRecHeatCe.uwReal = (UWORD)cp_stControlPara.swAlmMotorRecOHeatVal;
//        Syspara2.stMControlPara.uwPwrLimitMotorStartCe.uwReal = (UWORD)cp_stControlPara.swAlmPwrLimitMotorStartTempVal;
        Syspara2.stMControlPara.uwControlFunEN.uwReal = ass_stParaCong.uwControlFunEN;
        Syspara2.stMControlPara.uwThrottleGearEN.uwReal = ass_stParaCong.uwThrottleGearEN;
    }
    if (MC_UpcInfo.stSensorInfo.uwSaveFlg == TRUE)
    {
        Syspara2.stSensorPara.uwTorSensorOffsetOrigin.uwReal = torsensor_stTorSensorCof.uwTorqueOffsetOrign;
        Syspara2.stSensorPara.uwTorSensorOffsetNow1.uwReal = torsensor_stTorSensorCof.uwTorqueOffsetNow1;
        Syspara2.stSensorPara.uwTorSensorOffsetNow2.uwReal = torsensor_stTorSensorCof.uwTorqueOffsetNow2;
        Syspara2.stSensorPara.uwTorSensorOffsetNow3.uwReal = torsensor_stTorSensorCof.uwTorqueOffsetNow3;
        Syspara2.stSensorPara.uwTorSensorOffsetNow4.uwReal = torsensor_stTorSensorCof.uwTorqueOffsetNow4;
        Syspara2.stSensorPara.uwBikeTorMaxNm.uwReal = torsensor_stTorSensorCof.uwMaxSensorTorquePu;
        Syspara2.stSensorPara.uwBikeTor1StepRealNm.uwReal = torsensor_stTorSensorCof.uwBikeTorStep1RealNm;
        Syspara2.stSensorPara.uwBikeTor1StepADC.uwReal = torsensor_stTorSensorCof.uwBikeTorStep1ADC;
        Syspara2.stSensorPara.uwBikeTor2StepRealNm.uwReal = torsensor_stTorSensorCof.uwBikeTorStep2RealNm;
        Syspara2.stSensorPara.uwBikeTor2StepADC.uwReal = torsensor_stTorSensorCof.uwBikeTorStep2ADC;
        Syspara2.stSensorPara.uwBikeTor3StepRealNm.uwReal = torsensor_stTorSensorCof.uwBikeTorStep3RealNm;
        Syspara2.stSensorPara.uwBikeTor3StepADC.uwReal = torsensor_stTorSensorCof.uwBikeTorStep3ADC;
        Syspara2.stSensorPara.uwBikeTor4StepRealNm.uwReal = torsensor_stTorSensorCof.uwBikeTorStep4RealNm;
        Syspara2.stSensorPara.uwBikeTor4StepADC.uwReal = torsensor_stTorSensorCof.uwBikeTorStep4ADC;
        Syspara2.stSensorPara.uwCadSensorPulseNm.uwReal = cadence_stFreGetCof.uwNumbersPulses;
        Syspara2.stSensorPara.uwBikeSpdSensorPulseNm.uwReal = bikespeed_stFreGetCof.uwNumbersPulses;
    }
    if (MC_UpcInfo.stAssistInfo.uwSaveFlg == TRUE)
    {
        Syspara2.stAssistPara.uwStartupGain.uwReal = ass_stParaSet.uwStartupCoef;
        Syspara2.stAssistPara.uwStartcruiseGain.uwReal = ass_stParaSet.uwStartupCruiseCoef;
        Syspara2.stAssistPara.uwAssistStartNm.uwReal = ass_stParaSet.uwAssistStartNm;
        Syspara2.stAssistPara.uwAssistStopNm.uwReal = ass_stParaSet.uwAssistStopNm;
        Syspara2.stAssistPara.uwStartUpGainStep.uwReal = ass_stParaSet.uwStartUpGainStep;
        Syspara2.stAssistPara.uwStartUpCadNm.uwReal = ass_stParaSet.uwStartUpCadNm;
        Syspara2.stAssistPara.uwTorLPFCadNm.uwReal = ass_stParaSet.uwTorLPFCadNm;
        Syspara2.stAssistPara.uwSpeedAssistSpdRpm.uwReal = ass_stParaSet.uwSpeedAssistSpdRpm;
        Syspara2.stAssistPara.uwSpeedAssistIMaxA.uwReal = ass_stParaSet.uwSpeedAssistIMaxA;
        Syspara2.stAssistPara.uwAssistLimitBikeSpdStart.uwReal = ass_stParaSet.uwAssistLimitBikeSpdStart;
        Syspara2.stAssistPara.uwAssistLimitBikeSpdStop.uwReal = ass_stParaSet.uwAssistLimitBikeSpdStop;
        Syspara2.stAssistPara.uwCadenceAssistWeight.uwReal = ass_stParaSet.uwCadenceWeight;
    }
}
/***************************************************************
 Function: mn_voSoftwareInit;
 Description:software intial
 Call by:
 Input Variables: N/A
 Output/Return Variables: N/A
 Subroutine Call: N/A;
 Reference: N/A
****************************************************************/
void mn_voEEHistoryParaUpdate(void)
{
    Syspara2.stHistoryPara.uwAssModSelect.uwReal = ass_stParaSet.uwAsssistSelectNum;
    Syspara2.stHistoryPara.uwOpenTimes.uwReal = cp_stHistoryPara.uwOpenTimes;
    Syspara2.stHistoryPara.uwUsedTimeH.uwReal = (UWORD)(cp_stHistoryPara.ulUsedTime >> 16);
    Syspara2.stHistoryPara.uwUsedTimeL.uwReal = (UWORD)cp_stHistoryPara.ulUsedTime;
    Syspara2.stHistoryPara.uwNTCTempMaxCe.uwReal = cp_stHistoryPara.uwNTCTempMaxCe;
    Syspara2.stHistoryPara.uwNTCTempMinCe.uwReal = cp_stHistoryPara.uwNTCTempMinCe;

    Syspara2.stHistoryPara.uwAlamHOcurTimes.uwReal = cp_stHistoryPara.uwAlamHOcurTimes;
    Syspara2.stHistoryPara.uwAlamSOcurTimes.uwReal = cp_stHistoryPara.uwAlamSOcurTimes;
    Syspara2.stHistoryPara.uwAlamOHeatTimes.uwReal = cp_stHistoryPara.uwAlamOHeatTimes;
    Syspara2.stHistoryPara.uwAlamRotorLockTimes.uwReal = cp_stHistoryPara.uwAlamRotorLockTimes;
    Syspara2.stHistoryPara.uwAlamPhsLossTimes.uwReal = cp_stHistoryPara.uwAlamPhsLossTimes;
    Syspara2.stHistoryPara.uwAlamOVolTimes.uwReal = cp_stHistoryPara.uwAlamOVolTimes;
    Syspara2.stHistoryPara.uwAlamUVolTimes.uwReal = cp_stHistoryPara.uwAlamUVolTimes;
    Syspara2.stHistoryPara.uwAlamComOTimeTimes.uwReal = cp_stHistoryPara.uwAlamComOTimeTimes;

    Syspara2.stHistoryPara.uwG1AvgPwrConsumption.uwReal = cp_stHistoryPara.uwG1AvgPwrConsumption;
    Syspara2.stHistoryPara.uwG2AvgPwrConsumption.uwReal = cp_stHistoryPara.uwG2AvgPwrConsumption;
    Syspara2.stHistoryPara.uwG3AvgPwrConsumption.uwReal = cp_stHistoryPara.uwG3AvgPwrConsumption;
    Syspara2.stHistoryPara.uwG4AvgPwrConsumption.uwReal = cp_stHistoryPara.uwG4AvgPwrConsumption;
    Syspara2.stHistoryPara.uwG5AvgPwrConsumption.uwReal = cp_stHistoryPara.uwG5AvgPwrConsumption;

    Syspara2.stHistoryPara.uwODOTripH.uwReal = (UWORD)(cp_stHistoryPara.ulODOTrip >> 16);
    Syspara2.stHistoryPara.uwODOTripL.uwReal = (UWORD)cp_stHistoryPara.ulODOTrip;
    Syspara2.stHistoryPara.uwODOTimeH.uwReal = (UWORD)(cp_stHistoryPara.ulODOTime >> 16);
    Syspara2.stHistoryPara.uwODOTimeL.uwReal = (UWORD)cp_stHistoryPara.ulODOTime;

    Syspara2.stHistoryPara.uwTripSumH.uwReal = (UWORD)(cp_stHistoryPara.ulTripSum >> 16);
    Syspara2.stHistoryPara.uwTripSumL.uwReal = (UWORD)cp_stHistoryPara.ulTripSum;
    Syspara2.stHistoryPara.uwTripSumTimeH.uwReal = (UWORD)(cp_stHistoryPara.ulTripSumTime >> 16);
    Syspara2.stHistoryPara.uwTripSumTimeL.uwReal = (UWORD)cp_stHistoryPara.ulTripSumTime;

    Syspara2.stHistoryPara.uwTorSensorAlamTimes.uwReal = cp_stHistoryPara.uwTorSensorAlamTimes;
    Syspara2.stHistoryPara.uwCadSensorAlamTimes.uwReal = cp_stHistoryPara.uwCadSensorAlamTimes;
    Syspara2.stHistoryPara.uwBikeSpdSensorAlamTimes.uwReal = cp_stHistoryPara.uwBikeSpdSensorAlamTimes;
    Syspara2.stHistoryPara.uwPosSensorAlamTimes.uwReal = cp_stHistoryPara.uwPosSensorAlamTimes;
    
    Syspara2.stHistoryPara.uwRealODOTripH.uwReal = (UWORD)(cp_stHistoryPara.ulRealODOTrip >> 16);
    Syspara2.stHistoryPara.uwRealODOTripL.uwReal = (UWORD)cp_stHistoryPara.ulRealODOTrip;
    Syspara2.stHistoryPara.uwRealODOTimeH.uwReal = (UWORD)(cp_stHistoryPara.ulRealODOTime >> 16);
    Syspara2.stHistoryPara.uwRealODOTimeL.uwReal = (UWORD)cp_stHistoryPara.ulRealODOTime;
    
    if (MC_UpcInfo.stRideParaInfo.uwSaveFlg == TRUE)
    {       
        Syspara2.stRidePara.ucAssistRatioGain1.ucReal = ass_stCalCoef.ucAssistRatioGain[0];
        Syspara2.stRidePara.ucAssistRatioGain2.ucReal = ass_stCalCoef.ucAssistRatioGain[1];
        Syspara2.stRidePara.ucAssistRatioGain3.ucReal = ass_stCalCoef.ucAssistRatioGain[2];
        Syspara2.stRidePara.ucAssistRatioGain4.ucReal = ass_stCalCoef.ucAssistRatioGain[3];
        Syspara2.stRidePara.ucAssistRatioGain5.ucReal = ass_stCalCoef.ucAssistRatioGain[4];
        
        Syspara2.stRidePara.ucAssistAccelerationGain1.ucReal = ass_stCalCoef.ucAssistAccelerationGain[0];
        Syspara2.stRidePara.ucAssistAccelerationGain2.ucReal = ass_stCalCoef.ucAssistAccelerationGain[1];
        Syspara2.stRidePara.ucAssistAccelerationGain3.ucReal = ass_stCalCoef.ucAssistAccelerationGain[2];
        Syspara2.stRidePara.ucAssistAccelerationGain4.ucReal = ass_stCalCoef.ucAssistAccelerationGain[3];
        Syspara2.stRidePara.ucAssistAccelerationGain5.ucReal = ass_stCalCoef.ucAssistAccelerationGain[4];
        
        Syspara2.stRidePara.ucMaxCurrentGain1.ucReal = ass_stCalCoef.ucMaxCurrentGain[0];
        Syspara2.stRidePara.ucMaxCurrentGain2.ucReal = ass_stCalCoef.ucMaxCurrentGain[1];
        Syspara2.stRidePara.ucMaxCurrentGain3.ucReal = ass_stCalCoef.ucMaxCurrentGain[2];
        Syspara2.stRidePara.ucMaxCurrentGain4.ucReal = ass_stCalCoef.ucMaxCurrentGain[3];
        Syspara2.stRidePara.ucMaxCurrentGain5.ucReal = ass_stCalCoef.ucMaxCurrentGain[4];
        
        Syspara2.stRidePara.ucMaxTorqueGain1.ucReal = ass_stCalCoef.ucMaxTorqueGain[0];
        Syspara2.stRidePara.ucMaxTorqueGain2.ucReal = ass_stCalCoef.ucMaxTorqueGain[1];
        Syspara2.stRidePara.ucMaxTorqueGain3.ucReal = ass_stCalCoef.ucMaxTorqueGain[2];
        Syspara2.stRidePara.ucMaxTorqueGain4.ucReal = ass_stCalCoef.ucMaxTorqueGain[3];
        Syspara2.stRidePara.ucMaxTorqueGain5.ucReal = ass_stCalCoef.ucMaxTorqueGain[4];
        
    }
    
    //Syspara2.stBikePara2.swDeltaBikeSpeedLimit.swReal = (SWORD)ass_stParaCong.swDeltaBikeSpeedLimit;
    if (MC_UpcInfo.stBikeInfo2.uwSaveFlg == TRUE)
    {
        Syspara2.stBikePara2.uwNoneOBCEnable.uwReal = (UWORD)ass_stParaCong.uwNoneOBCEnable;
        Syspara2.stBikePara2.uwRearLightCycle.uwReal = (UWORD)ass_stParaCong.uwRearLightCycle;
        Syspara2.stBikePara2.uwRearLightDuty.uwReal = (UWORD)ass_stParaCong.uwRearLightDuty;
        Syspara2.stBikePara2.swDeltaBikeSpeedLimit.swReal = (SWORD)ass_stParaCong.swDeltaBikeSpeedLimit;
    }
}

/***************************************************************
 Function: mn_voSoftwareInit;
 Description:software intial
 Call by:
 Input Variables: N/A
 Output/Return Variables: N/A
 Subroutine Call: N/A;
 Reference: N/A
****************************************************************/
void mn_voSoftwareInit(void)
{
    /* System coefficient calculate */
    cof_voSysInit();
    /* Motor parameter init */
    //   mn_voMtParInit();
    /* Control Parameters init */
    mn_voMcParInit();
    /*cmd handle Initial */
    cmd_voCmdInit();
    /* FSM init */
    FSM_voInit();
    RUN_FSM_voInit();
    Switch_speed_FSMInit();
    
    /* TempInit */
    TempInit();

    /* CANInit */
    Can_voInitMC_Run();

    /* Alarm init */
    alm_voInit();
    alm_voCoef();
    /* ADC init */
    adc_voSampleInit();
    adc_voSampleCoef(&adc_stCof);
    /* UART init */
    uart_voMonitorInit();
}

/************************************************************************
 Function: void mn_voMtParInit(void)
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
************************************************************************/
void mn_voMtParInit(void)
{
//    mn_swIdTurn1Pu = (SWORD)(((SLONG)M_LD_TURN1_ID_AP << 14) / (SWORD)cof_uwIbAp); // Q14, saturation current of Ld
//    mn_slLdTurn1Pu = ((SLONG)M_LD_TURN1_LD_MH << 10) / cof_uwLbHm; // Q10, saturation inductance of Ld
//    mn_swIdTurn2Pu = (SWORD)(((SLONG)M_LD_TURN2_ID_AP << 14) / (SWORD)cof_uwIbAp); // Q14, saturation current of Ld
//    mn_slLdTurn2Pu = ((SLONG)M_LD_TURN2_LD_MH << 10) / cof_uwLbHm; // Q10, saturation inductance of Ld
//    if (mn_swIdTurn1Pu == mn_swIdTurn2Pu)
//    {
//        mn_swKLdSat = 0;
//    }
//    else
//    {
//        mn_swKLdSat = (SWORD)(((mn_slLdTurn2Pu - mn_slLdTurn1Pu) << 10) / (mn_swIdTurn2Pu - mn_swIdTurn1Pu)); // Q10
//    }
//
//    mn_swIqTurn1Pu = (SWORD)(((SLONG)M_LQ_TURN1_IQ_AP << 14) / (SWORD)cof_uwIbAp); // Q14, saturation current of Lq
//    mn_slLqTurn1Pu = ((SLONG)M_LQ_TURN1_LQ_MH << 10) / cof_uwLbHm; // Q10, saturation inductance of Lq
//    mn_swIqTurn2Pu = (SWORD)(((SLONG)M_LQ_TURN2_IQ_AP << 14) / (SWORD)cof_uwIbAp); // Q14, saturation current of Lq
//    mn_slLqTurn2Pu = ((SLONG)M_LQ_TURN2_LQ_MH << 10) / cof_uwLbHm; // Q10, saturation inductance of Lq
//    if (mn_swIqTurn1Pu == mn_swIqTurn2Pu)
//    {
//        mn_swKLqSat = 0;
//    }
//    else
//    {
//        mn_swKLqSat = (SWORD)(((mn_slLqTurn2Pu - mn_slLqTurn1Pu) << 10) / (mn_swIqTurn2Pu - mn_swIqTurn1Pu)); // Q10
//    }
}

/************************************************************************
 Function: void mn_voMcParInit(void)
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
************************************************************************/
void mn_voMcParInit(void)
{
    align_voInit();

    // Align Parameters
    mn_uwAlignCurPu = (UWORD)CUR_AP2PU(cp_stControlPara.swAlignCurAp); // Q14
    mn_ulAlignRampTbcCt = TBC_MS2CT(cp_stControlPara.swAlignRampTMms);
    mn_ulAlignHoldTbcCt = TBC_MS2CT(cp_stControlPara.swAlignHoldTMms);
    if (mn_ulAlignRampTbcCt == 0)
    {
        mn_ulAlignCurIncPerTbcPu = 1;
    }
    else
    {
        mn_ulAlignCurIncPerTbcPu = ((ULONG)mn_uwAlignCurPu << 15) / mn_ulAlignRampTbcCt; // Q29
        if (mn_ulAlignCurIncPerTbcPu == 0)
        {
            mn_ulAlignCurIncPerTbcPu = 1;
        }
    }
    mn_slAlignAngInit = ANG_DEG2PU(cp_stControlPara.swAlignAngInitDeg);

    // Open Drag Parameters
    mn_uwDragCurPu = (UWORD)CUR_AP2PU(cp_stControlPara.swDragCurAp); // Q14
    mn_swDragSpdPu = (SWORD)SPD_HZ2PU(cp_stControlPara.swDragSpdHz); // Q15
    mn_ulDragSpdRampTbcCt = TBC_MS2CT(cp_stControlPara.swDragSpdRampTMms);
    if (mn_ulDragSpdRampTbcCt == 0)
    {
        mn_ulDragSpdIncPerTbcPu = 1;
    }
    else
    {
        mn_ulDragSpdIncPerTbcPu = ((ULONG)mn_swDragSpdPu << 14) / mn_ulDragSpdRampTbcCt; // Q29
        if (mn_ulDragSpdIncPerTbcPu == 0)
        {
            mn_ulDragSpdIncPerTbcPu = 1;
        }
    }
    // Open to Close Parameters
    mn_ulOpen2ClzCurRampTbcCt = TBC_MS2CT(cp_stControlPara.swOpen2ClzRampTMms);
    if (mn_ulOpen2ClzCurRampTbcCt == 0)
    {
        mn_ulOpen2ClzCurIncPerTbcPu = 1;
    }
    else
    {
        mn_ulOpen2ClzCurIncPerTbcPu = (ULONG)mn_uwDragCurPu / mn_ulOpen2ClzCurRampTbcCt;
        if (mn_ulOpen2ClzCurIncPerTbcPu == 0)
        {
            mn_ulOpen2ClzCurIncPerTbcPu = 1;
        }
    }
    // Stop Parameters
    mn_swStopSpdRefPu = (SWORD)SPD_RPM2PU(cp_stControlPara.swStopSpdRefRpm);
}

/***************************************************************
 Function: mn_voIPMSeletion;
 Description:software intial
 Call by:
 Input Variables: N/A
 Output/Return Variables: N/A
 Subroutine Call: N/A;
 Reference: N/A
****************************************************************/
// void mn_voIPMSelection(void)
// {
//     //Dead band time and Turn on/off time
//     hw_uwPwmDeadBandTmNs = cp_stControlPara.swIPMDeadTimeNs;
//     mn_uwIpmDeadBandTmNs = cp_stControlPara.swIPMDeadTimeNs;
//     mn_uwIpmTurnOnTmNs = cp_stControlPara.swIPMTurnOnNs;
//     mn_uwIpmTurnOffTmNs = cp_stControlPara.swIPMTurnOffNs;
//     //HVIC charge parameters
//     mn_ulHvicChrgTmTbcCt = EVENT1MS_MS2CT(cp_stControlPara.swIPMHvicChrgMs);
//     //Max duty cyle
//     mn_uwPwmMaxDutyCyle = cp_stControlPara.swPWMMaxDuty;
//     mn_uwPwm7SvmTo5SvmDuty = cp_stControlPara.swPWM7to5Duty;
//     mn_uwPWMMinSample1Pu = cp_stControlPara.swPWMMinSampleDuty1;
//     mn_uwPWMMinSample2Pu = cp_stControlPara.swPWMMinSampleDuty2;
//     mn_uwFlxMaxDutyCyle = cp_stControlPara.swFwPWMMaxDuty;
//     //Current sample parameters
//     pwm_sw1stCurSmplCt = cp_stControlPara.swPWM1STSampleCnt;
//     pwm_sw2ndCurSmplCt = cp_stControlPara.swPWM2NDSampleCnt;
//     pwm_swMinDoubleCurSmplPu = (cp_stControlPara.swPWMMinEffVectorPu << 1);
//     pwm_swMinCurSmplCt = cp_stControlPara.swPWMMinEffVectorCnt;
//     pwm_swMinCurSmplPu = cp_stControlPara.swPWMMinEffVectorPu;
// }
/*************************************************************************
 Copyright (c) 2018 Welling Motor Technology(Shanghai) Co. Ltd.
 All rights reserved.
*************************************************************************/
#ifdef _MAIN_C_
#undef _MAIN_C_ /* parasoft-suppress MISRA2004-19_6 "本项目无法更改，后续避免使用" */
#endif
/*************************************************************************
 End of this File (EOF)!
 Do not put anything after this part!
*************************************************************************/