motor_ctl-1/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 "CadAssist.h"
#include "bikeinformation.h"
#include "FSM_1st.h"
#include "FSM_2nd.h"
#include "FuncLayerAPI.h"
#include "usart.h"
#include "cmdgennew.h"
#include "canAppl.h"
#include "flash_master.h"
#include "string.h"
//#include "at32f421_wk_config.h"
//#include "SEGGER_RTT.h"
#include "UserGpio_Config.h"
//#include "api_rt.h"
//#include "profiler.h"

#include "ti_msp_dl_config.h"
/************************************************************************
 Exported Functions:
************************************************************************/
void AppInit();
void AppLoop();
void LED_ResDispaly(void);

//void delay_125us(void);
void delay_125us(int count)
{
    for(int i=0;i<count;i++)
    {
        delay_cycles(10000);
    }
}

/* This results in approximately 0.25s of delay assuming 80MHz CPU_CLK */
#define DELAY (40000000)
unsigned int ACnt;    // Variable: speed control period counter



/***************************************************************
 Function: main;
 Description:main function
 Call by:
 Input Variables: N/A
 Output/Return Variables: N/A
 Subroutine Call: N/A;
 Reference: N/A
****************************************************************/

/*
 * Timer clock configuration to be sourced by  / 1 (72000000 Hz)
 * timerClkFreq = (timerClkSrc / (timerClkDivRatio * (timerClkPrescale + 1)))
 *   72000000 Hz = 72000000 Hz / (1 * (0 + 1))
 */
static const DL_TimerA_ClockConfig gPWM_0_COPYClockConfig = {
    .clockSel = DL_TIMER_CLOCK_BUSCLK,
    .divideRatio = DL_TIMER_CLOCK_DIVIDE_1,
    .prescale = 0U
};

static const DL_TimerA_PWMConfig gPWM_0_COPYConfig = {
    .pwmMode = DL_TIMER_PWM_MODE_CENTER_ALIGN,
    .period = 4500,
    .isTimerWithFourCC = false,
    .startTimer = DL_TIMER_STOP,
};

SYSCONFIG_WEAK void SYSCFG_DL_PWM_0_COPY_init(void) {


    DL_TimerA_reset(TIMA1);
    DL_TimerA_enablePower(TIMA1);
    delay_cycles(POWER_STARTUP_DELAY);
    DL_TimerA_setClockConfig(
            TIMA1, (DL_TimerA_ClockConfig *) &gPWM_0_COPYClockConfig);

    DL_TimerA_initPWMMode(
            TIMA1, (DL_TimerA_PWMConfig *) &gPWM_0_COPYConfig);

    DL_TimerA_setCaptureCompareOutCtl(TIMA1, DL_TIMER_CC_OCTL_INIT_VAL_LOW,
        DL_TIMER_CC_OCTL_INV_OUT_DISABLED, DL_TIMER_CC_OCTL_SRC_FUNCVAL,
        DL_TIMERA_CAPTURE_COMPARE_0_INDEX);

    DL_TimerA_setCaptCompUpdateMethod(TIMA1, DL_TIMER_CC_UPDATE_METHOD_IMMEDIATE, DL_TIMERA_CAPTURE_COMPARE_0_INDEX);
    DL_TimerA_setCaptureCompareValue(TIMA1, 2250, DL_TIMER_CC_0_INDEX);

    DL_TimerA_enableClock(TIMA1);


    DL_TimerA_enableInterrupt(TIMA1 , DL_TIMER_INTERRUPT_LOAD_EVENT |
        DL_TIMER_INTERRUPT_ZERO_EVENT);

    NVIC_SetPriority(TIMA1_INT_IRQn, 2);
    DL_TimerA_setCCPDirection(TIMA1 , DL_TIMER_CC0_OUTPUT );



     /* DL_TIMER_CROSS_TRIG_SRC is a Don't Care field when Cross Trigger Source is set to Software */
    DL_TimerA_configCrossTrigger(TIMA1, DL_TIMER_CROSS_TRIG_SRC_FSUB0,
    DL_TIMER_CROSS_TRIGGER_INPUT_DISABLED, DL_TIMER_CROSS_TRIGGER_MODE_ENABLED
        );

    DL_TimerA_setCaptureCompareInput(TIMA1, DL_TIMER_CC_INPUT_INV_NOINVERT, DL_TIMER_CC_IN_SEL_TRIG, DL_TIMER_CC_0_INDEX);

    /*
     * Determines the external triggering event to trigger the module (self-triggered in main configuration)
     * and triggered by specific timer in secondary configuration
     */
    DL_TimerA_setExternalTriggerEvent(TIMA1,DL_TIMER_EXT_TRIG_SEL_TRIG_1);
    DL_TimerA_enableExternalTrigger(TIMA1);
    uint32_t temp;
    temp = DL_TimerA_getCaptureCompareCtl(TIMA1, DL_TIMER_CC_0_INDEX);
    DL_TimerA_setCaptureCompareCtl(TIMA1, DL_TIMER_CC_MODE_COMPARE, temp | (uint32_t) DL_TIMER_CC_LCOND_TRIG_RISE, DL_TIMER_CC_0_INDEX);

}

int  main(void)
{
    SCB->VTOR =APP_START_Address;//

    /* Disable all interrupts */
    DISABLE_IRQ;
    /* MCU Core and GPIO configuration */

    SYSCFG_DL_init();
    SYSCFG_DL_PWM_0_COPY_init();
    Reset_POWER_LOCK_PORT();
    //TIMA0  MOTOR_PWM
    DL_Timer_setCaptCompUpdateMethod(MOTOR_PWM_INST,DL_TIMER_CC_UPDATE_METHOD_ZERO_EVT,DL_TIMERA_CAPTURE_COMPARE_0_INDEX);
    DL_Timer_setCaptCompUpdateMethod(MOTOR_PWM_INST,DL_TIMER_CC_UPDATE_METHOD_ZERO_EVT,DL_TIMERA_CAPTURE_COMPARE_1_INDEX);
    DL_Timer_setCaptCompUpdateMethod(MOTOR_PWM_INST,DL_TIMER_CC_UPDATE_METHOD_ZERO_EVT,DL_TIMERA_CAPTURE_COMPARE_2_INDEX);
    NVIC_EnableIRQ(ADC12_0_INST_INT_IRQN);
    //DL_Timer_setCaptCompUpdateMethod(PWM_F_INST,DL_TIMER_CC_UPDATE_METHOD_ZERO_EVT,DL_TIMER_CC_1_INDEX);
    NVIC_EnableIRQ(HALLTIMER_INST_INT_IRQN); //

    DL_TimerA_setCaptureCompareValue(MOTOR_PWM_INST, 0, DL_TIMER_CC_0_INDEX);
    DL_TimerA_setCaptureCompareValue(MOTOR_PWM_INST, 0, DL_TIMER_CC_1_INDEX);
    DL_TimerA_setCaptureCompareValue(MOTOR_PWM_INST, 0, DL_TIMER_CC_2_INDEX);

    DL_Timer_clearInterruptStatus(MOTOR_PWM_INST,DL_TIMER_INTERRUPT_FAULT_EVENT|DL_TIMER_INTERRUPT_ZERO_EVENT);
    DL_Timer_clearEventsStatus(MOTOR_PWM_INST,1,DL_TIMER_EVENT_FAULT_EVENT);

    DL_TimerA_setCaptureCompareValue(MOTOR_PWM_INST,2, DL_TIMER_CC_4_INDEX);
    //HALL IO
    NVIC_EnableIRQ(GPIOA_INT_IRQn);  //HALL GPIO
    NVIC_EnableIRQ(GPIOB_INT_IRQn);  //HALL GPIO

#if(EMCDEAL_EN!=0) //霍尔定时换相计时中断
    NVIC_EnableIRQ(HALL_CNT_INST_INT_IRQN);
    DL_TimerG_startCounter(HALL_CNT_INST);
#endif

    //LED 前灯比较器
//     NVIC_EnableIRQ(COMP_FLEDCHECK_INST_INT_IRQN);
//     DL_COMP_enable(COMP_FLEDCHECK_INST);

     // over Cur CMP
//     DL_COMP_enable(COMP_0_INST);
//     NVIC_EnableIRQ(COMP_0_INST_INT_IRQN);

  //Start MOTOR 计数
    DL_TimerA_startCounter(MOTOR_PWM_INST);
//    DL_TimerA_startCounter(TIMER_0_INST);
    DL_TimerA_generateCrossTrigger(TIMA1);
    NVIC_EnableIRQ(TIMA1_INT_IRQn); //MOTOR PWM

      // DL_Timer_setCoreHaltBehavior(TIMA0,DL_TIMER_CORE_HALT_IMMEDIATE);
    NVIC_EnableIRQ(MOTOR_PWM_INST_INT_IRQN); //MOTOR PWM

//LED pwm 开始计数
   // DL_TimerG_startCounter(TIMG12);
    DL_TimerG_startCounter(PWM_R_INST);
    DL_TimerG_startCounter(PWM_F_INST);
    DL_TimerG_startCounter(PWM_B_L_INST);

//    DL_GPIO_clearPins(OUTPUT_CAN_STB_PORT, OUTPUT_CAN_STB_PIN);
//    DL_GPIO_setPins(OUTPUT_CAN_STB_PORT, OUTPUT_CAN_STB_PIN);
//    DL_GPIO_togglePins(OUTPUT_CAN_STB_PORT, OUTPUT_CAN_STB_PIN);

//
//    /* Set output voltage:
//     *  DAC value (12-bits) = DesiredOutputVoltage x 4095
//     *                          -----------------------
//     *                              ReferenceVoltage


     DL_DAC12_output12(DAC0, 2048);
     DL_DAC12_enable(DAC0);

     //---over Cur of Valut
#if((IPM_POWER_SEL == IPM_POWER_250W_6G) ||(IPM_POWER_SEL ==IPM_POWER_350W_6G)||(IPM_POWER_SEL ==IPM_POWER_500W_6G))
     DL_COMP_setDACCode0(COMP_0_INST, 0xb5);//12G-100A-0x99-1.97V   6G-70A--0xb5-2.33V
#else
    DL_COMP_setDACCode0(COMP_0_INST, 0x81);//12G-100A-0x99-1.97V   6G-60A--0xb5-2.33V
#endif

//    hw_voHardwareSetup1();
    /* Api Init*/
   // iRt_Init();
    /* Api App Init*/
    AppInit();
    /* Peripheral configuration */
    hw_voHardwareSetup2();
    /* Timer enable */
    hw_voTimEn();
    /* Interrupts of peripherals enable*/
    hw_voEnInt();
    
    TORG4BB_Init();

    /* self test init */
    //stl_voRunTimeChecksInit();
    /* watchdog 1s */
//    wk_wdt_init();//  hw_voIWDGInit(IWDG_Prescaler_32,2500);//1s  看门狗
   // que_voInit(&stFlashErrorLog);
    /* Error Log Read */
     // flash_voErrorRead();
    /* Enable all interrupts */

    NVIC_ClearPendingIRQ(UART_HMI_INST_INT_IRQN);
    NVIC_EnableIRQ(UART_HMI_INST_INT_IRQN);

    NVIC_ClearPendingIRQ(MCAN0_INST_INT_IRQN);
    NVIC_EnableIRQ(MCAN0_INST_INT_IRQN);

    ENABLE_IRQ;
//    DL_GPIO_setPins(LED_PORT, LED_LED1_PIN);
//    DL_GPIO_setPins(LED_PORT, LED_LED2_PIN);

  //  delay_cycles(DELAY);
//    delay_cycles(DELAY);
//    delay_cycles(DELAY);
//    delay_cycles(DELAY);
//    delay_cycles(DELAY);
//    delay_cycles(DELAY);
//    delay_cycles(DELAY);
//    delay_cycles(DELAY);
//    delay_cycles(DELAY);
//    delay_cycles(DELAY);


    /* Enter infinite loop */
#if(JSCOPE_EN!=0)
     Jscope_Init();
#endif
 #if(EMCDEAL_EN!=0)
   //  LED_ResDispaly();
     #endif
    // flash_voSysParaWrite();
     uwFlash_IRQ_Enble=1;
    // hw_voPWMOn();
     // DL_TimerG_setCaptureCompareValue(PWM_B_INST, 1000, GPIO_PWM_B_C1_IDX);
    while (1)
    {
//        DL_GPIO_togglePins(LED_PORT, LED_LED1_PIN);
//        DL_GPIO_togglePins(LED_PORT, LED_LED2_PIN);
          AppLoop();
//          PROFILER_BG();
          ACnt++;

//           delay_cycles(DELAY);
//           DL_TimerA_setCaptureCompareValue(MOTOR_PWM_INST, 1875, DL_TIMER_CC_0_INDEX);
//          DL_TimerA_setCaptureCompareValue(MOTOR_PWM_INST, 1250, DL_TIMER_CC_2_INDEX);
//          DL_TimerA_setCaptureCompareValue(MOTOR_PWM_INST, 625, DL_TIMER_CC_3_INDEX);
//
 //         DL_TimerG_setCaptureCompareValue(LED_PWM_INST, 100, DL_TIMER_CC_0_INDEX);
 //         DL_TimerG_setCaptureCompareValue(LED_PWM_INST, 100, DL_TIMER_CC_1_INDEX);
    }

}
/***************************************************************
 Function: mn_voParaSet;
 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)
{
 
     flash_voSysParaRead();//i2c_voSysparaReadFromEE(&i2c_stRXCRCOut);
     flash_voErrorRead();
     flash_HistoryRead();
     flash_voProductParaRead();
    //flash_voMosResParaRead();
    i2c_stRXCRCOut.ReadFinishFlg = TRUE;
    if (i2c_stRXCRCOut.blHistoryParaFltFlg == FALSE)
    {
        ass_ParaSet.uwAsssistSelectNum =stHistoryPara.uwAssModSelect.uwReal;  // I2C_uwHistoryParaRead[0];
        cp_stHistoryPara.uwOpenTimes = stHistoryPara.uwOpenTimes.uwReal  ;//I2C_uwHistoryParaRead[1];
        cp_stHistoryPara.ulUsedTime =(((ULONG)stHistoryPara.uwUsedTimeH.uwReal)<<16) + stHistoryPara.uwUsedTimeL.uwReal  ;// (((ULONG)I2C_uwHistoryParaRead[2]) << 16) + I2C_uwHistoryParaRead[3];
        cp_stHistoryPara.swNTCTempMaxCe = stHistoryPara.swNTCTempMaxCe.swReal  ;//I2C_uwHistoryParaRead[4];
        cp_stHistoryPara.swNTCTempMinCe = stHistoryPara.swNTCTempMinCe.swReal  ;//I2C_uwHistoryParaRead[5];

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

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

        cp_stHistoryPara.ulODOTrip =(((ULONG)stHistoryPara.uwODOTripH.uwReal)<<16)  + stHistoryPara.uwODOTripL.uwReal  ;// (((ULONG)I2C_uwHistoryParaRead[19]) << 16) + I2C_uwHistoryParaRead[20];
        cp_stHistoryPara.ulODOTime =(((ULONG)stHistoryPara.uwODOTimeH.uwReal)<<16)  +stHistoryPara.uwODOTimeL.uwReal  ;// (((ULONG)I2C_uwHistoryParaRead[21]) << 16) + I2C_uwHistoryParaRead[22];
        cp_stHistoryPara.ulTripSum =(((ULONG)stHistoryPara.uwTripSumH.uwReal)<<16)  +stHistoryPara.uwTripSumL.uwReal  ;// (((ULONG)I2C_uwHistoryParaRead[23]) << 16) + I2C_uwHistoryParaRead[24];
        cp_stHistoryPara.ulTripSumTime =(((ULONG)stHistoryPara.uwTripSumTimeH.uwReal)<<16) +stHistoryPara.uwTripSumTimeL.uwReal ;// (((ULONG)I2C_uwHistoryParaRead[25]) << 16) + I2C_uwHistoryParaRead[26];

        cp_stHistoryPara.uwTorSensorAlamTimes =stHistoryPara.uwTorSensorAlamTimes.uwReal  ;// I2C_uwHistoryParaRead[27];
        cp_stHistoryPara.uwCadSensorAlamTimes =stHistoryPara.uwCadSensorAlamTimes.uwReal  ;// I2C_uwHistoryParaRead[28];
        cp_stHistoryPara.uwBikeSpdSensorAlamTimes = stHistoryPara.uwBikeSpdSensorAlamTimes.uwReal  ;//I2C_uwHistoryParaRead[29];
        cp_stHistoryPara.uwPosSensorAlamTimes =stHistoryPara.uwPosSensorAlamTimes.uwReal  ;// I2C_uwHistoryParaRead[30];
        cp_stHistoryPara.ulRealODOTrip =(((ULONG) stHistoryPara.uwRealODOTripH.uwReal)<<16)  +  stHistoryPara.uwRealODOTripL.uwReal;     //(((ULONG)I2C_uwHistoryParaRead[31]) << 16) + I2C_uwHistoryParaRead[32];
        cp_stHistoryPara.ulRealODOTime =(((ULONG) stHistoryPara.uwRealODOTimeH.uwReal )<<16)  + stHistoryPara.uwRealODOTimeL.uwReal ;   // (((ULONG)I2C_uwHistoryParaRead[33]) << 16) + I2C_uwHistoryParaRead[34];
    }
    else
    {}
    
    // peripheral Para Set
    cadence_stFreGetCof.uwTorque_NumbersPulses = TORQUE_NUMBERS_PULSES;
    cadence_stFreGetCof.uwCad_NumbersPulses    = 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 =Syspara2.stMotorPara.uwPolePairs.uwReal;// I2C_uwMotorParaRead[0];
                cp_stMotorPara.swRsOhm =Syspara2.stMotorPara.uwRsmOhm.uwReal; // I2C_uwMotorParaRead[1];
                cp_stMotorPara.uwLdmH = Syspara2.stMotorPara.uwLduH.uwReal ;//I2C_uwMotorParaRead[2];
                cp_stMotorPara.uwLqmH = Syspara2.stMotorPara.uwLquH.uwReal ;//I2C_uwMotorParaRead[3];
                cp_stMotorPara.swFluxWb = Syspara2.stMotorPara.uwFluxmWb.uwReal ;//I2C_uwMotorParaRead[4];
                cp_stMotorPara.swIdMaxA = Syspara2.stMotorPara.uwIdMaxA.uwReal ;//I2C_uwMotorParaRead[5];
                cp_stMotorPara.swIdMinA =Syspara2.stMotorPara.uwIdMinA.uwReal ;// I2C_uwMotorParaRead[6];
                cp_stMotorPara.swRSpeedRpm = Syspara2.stMotorPara.uwRSpdRpm.uwReal ;//I2C_uwMotorParaRead[7];
                cp_stMotorPara.uwRPwrWt = Syspara2.stMotorPara.uwRPwrWt.uwReal ;//I2C_uwMotorParaRead[8];
                cp_stMotorPara.swRIarmsA =Syspara2.stMotorPara.uwRCurA.uwReal ;// I2C_uwMotorParaRead[9];
                cp_stMotorPara.swRUdcV = Syspara2.stMotorPara.uwRVolV.uwReal ;//I2C_uwMotorParaRead[10];
                cp_stMotorPara.swJD = Syspara2.stMotorPara.uwJD.uwReal ;//I2C_uwMotorParaRead[11];
                cp_stMotorPara.swTorMax = Syspara2.stMotorPara.uwTorMaxNm.uwReal ;//I2C_uwMotorParaRead[12];
            }
            else
            {}
            if (i2c_stRXCRCOut.blBikeParaFltFlg == FALSE)
            {
                ass_ParaCong.uwWheelPerimeter =Syspara2.stBikePara.uwWheelPerimeter.uwReal  ;// I2C_uwBikeParaRead[0];
                ass_ParaCong.swDeltPerimeter = Syspara2.stBikePara.swDeltPerimeter.swReal  ;//I2C_uwBikeParaRead[1];
                ass_ParaCong.uwMechRationMotorEEPROM=Syspara2.stBikePara.uwMechRationMotor.uwReal;
                ass_ParaCong.uwMechRationMotor = (UWORD)(((ULONG)ass_ParaCong.uwMechRationMotorEEPROM*1024)/1000);//(UWORD)(((ULONG)I2C_uwBikeParaRead[2]*1024)/1000);
                ass_ParaCong.uwThrottleMaxSpdKmH =Syspara2.stBikePara.uwThrottleMaxSpdKmH.uwReal  ;// I2C_uwBikeParaRead[3];
                ass_ParaCong.uwCartSpdKmH =Syspara2.stBikePara.uwCartSpdKmH.uwReal ;// I2C_uwBikeParaRead[4];
                ass_ParaCong.uwNmFrontChainring =Syspara2.stBikePara.uwNmFrontChainring.uwReal  ;// I2C_uwBikeParaRead[5];
                ass_ParaCong.uwNmBackChainring =Syspara2.stBikePara.uwNmBackChainring.uwReal  ;// I2C_uwBikeParaRead[6];
                ass_ParaCong.uwAssistSelect1 =Syspara2.stBikePara.uwAssistSelect1.uwReal  ;// I2C_uwBikeParaRead[7];
                ass_ParaCong.uwAssistSelect2 =Syspara2.stBikePara.uwAssistSelect2.uwReal  ;// I2C_uwBikeParaRead[8];
                ass_ParaCong.uwLightConfig =Syspara2.stBikePara.uwLightConfig.uwReal  ;// I2C_uwBikeParaRead[9];
                ass_ParaCong.uwStartMode =Syspara2.stBikePara.uwStartMode.uwReal  ;// I2C_uwBikeParaRead[10];
                ass_ParaCong.uwAutoPowerOffTime =Syspara2.stBikePara.uwAutoPowerOffTime.uwReal  ;// I2C_uwBikeParaRead[11];
            }
            else
            {}
            if (i2c_stRXCRCOut.blMControlParaFltFlg == FALSE)
            {
                cp_stFlg.ParaFirstSetFlg =Syspara2.stMControlPara.ParaFirstSetFlg.uwReal ;// I2C_uwMControlRead[0];
                // cp_stFlg.SpiOffsetFirstSetFlg =Syspara2.stMControlPara.SpiOffsetFirstSetFlg ;// I2C_uwMControlRead[1];
                // spi_stResolverOut.swSpiThetaOffsetOrignPu =Syspara2.stMControlPara.uwSPIPosOffsetOrigin ;// I2C_uwMControlRead[2];
                // spi_stResolverOut.swSpiThetaOffsetPu =Syspara2.stMControlPara.uwSPIPosOffsetNow ;// I2C_uwMControlRead[3];
                cp_stMotorPara.swIpeakMaxA = Syspara2.stMControlPara.uwIPeakMaxA.uwReal ;//I2C_uwMControlRead[4];
                cp_stControlPara.swAlmOverCurrentVal =Syspara2.stMControlPara.uwAlamOCurA.uwReal ;// I2C_uwMControlRead[5];
                cp_stControlPara.swAlmOverVolVal1 =Syspara2.stMControlPara.uwAlamOVolV.uwReal ;// I2C_uwMControlRead[6];
                cp_stControlPara.swAlmUnderVolVal1 =Syspara2.stMControlPara.uwAlamUVolV.uwReal ;//I2C_uwMControlRead[7];
                cp_stControlPara.swAlmOverSpdVal =Syspara2.stMControlPara.uwAlamOverSpdRpm.uwReal ;// I2C_uwMControlRead[8];
                cp_stControlPara.swAlmOverHeatCeVal =Syspara2.stMControlPara.uwAlamOverHeatCe.uwReal ;// I2C_uwMControlRead[9];
                cp_stControlPara.swAlmRecOHeatVal =Syspara2.stMControlPara.uwAlamRecHeatCe.uwReal ;// I2C_uwMControlRead[10];
                cp_stControlPara.swAlmPwrLimitStartTempVal =Syspara2.stMControlPara.uwPwrLimitStartCe.uwReal ;// I2C_uwMControlRead[11];
                cp_stControlPara.swAlmMotorOverHeatCeVal =Syspara2.stMControlPara.uwAlamMotorOverHeatCe.uwReal ;// I2C_uwMControlRead[12];
                cp_stControlPara.swAlmMotorRecOHeatVal = Syspara2.stMControlPara.uwAlamMotorRecHeatCe.uwReal ;//I2C_uwMControlRead[13];
                cp_stControlPara.swAlmPwrLimitMotorStartTempVal =Syspara2.stMControlPara.uwPwrLimitMotorStartCe.uwReal ;// I2C_uwMControlRead[14];
                cp_stControlPara.uwControlFunEN=Syspara2.stMControlPara.uwControlFunEN.uwReal  ;//I2C_uwMControlRead[15];
                cp_stControlPara.swAlmRecOVVal=cp_stControlPara.swAlmOverVolVal1-10; //过压恢复值
                cp_stControlPara.swAlmRecUVVal=cp_stControlPara.swAlmUnderVolVal1+10;//欠压恢复值
                cp_stControlPara.swCvbConstantVolBrakeV=cp_stControlPara.swAlmRecOVVal;
            }
            else
            {
                cp_stFlg.RunPermitFlg = FALSE;
            }
            if (i2c_stRXCRCOut.blSensorParaFltFlg == FALSE)
            {
                torsensor_stTorSensorCof.uwTorqueOffsetOrign =Syspara2.stSensorPara.uwTorSensorOffsetOrigin.uwReal ;// I2C_uwSensorRead[0];
                torsensor_stTorSensorCof.uwTorqueOffsetNow1 =Syspara2.stSensorPara.uwTorSensorOffsetNow1.uwReal ;// I2C_uwSensorRead[1];
                torsensor_stTorSensorCof.uwTorqueOffsetNow2 =Syspara2.stSensorPara.uwTorSensorOffsetNow2.uwReal ;// I2C_uwSensorRead[2];
                torsensor_stTorSensorCof.uwTorqueOffsetNow3 =Syspara2.stSensorPara.uwTorSensorOffsetNow3.uwReal ;// I2C_uwSensorRead[3];
                torsensor_stTorSensorCof.uwTorqueOffsetNow4 =Syspara2.stSensorPara.uwTorSensorOffsetNow4.uwReal ;// I2C_uwSensorRead[4];
                torsensor_stTorSensorCof.uwMaxSensorTorquePu =Syspara2.stSensorPara.uwBikeTorMaxNm.uwReal ;// I2C_uwSensorRead[5];
                torsensor_stTorSensorCof.uwBikeTorStep1RealNm =Syspara2.stSensorPara.uwBikeTor1StepRealNm.uwReal ;// I2C_uwSensorRead[6];
                torsensor_stTorSensorCof.uwBikeTorStep1ADC =Syspara2.stSensorPara.uwBikeTor1StepADC.uwReal ;// I2C_uwSensorRead[7];
                torsensor_stTorSensorCof.uwBikeTorStep2RealNm =Syspara2.stSensorPara.uwBikeTor2StepRealNm.uwReal ;// I2C_uwSensorRead[8];
                torsensor_stTorSensorCof.uwBikeTorStep2ADC =Syspara2.stSensorPara.uwBikeTor2StepADC.uwReal ;// I2C_uwSensorRead[9];
                torsensor_stTorSensorCof.uwBikeTorStep3RealNm = Syspara2.stSensorPara.uwBikeTor3StepRealNm.uwReal ;//I2C_uwSensorRead[10];
                torsensor_stTorSensorCof.uwBikeTorStep3ADC =Syspara2.stSensorPara.uwBikeTor3StepADC.uwReal ;// I2C_uwSensorRead[11];
                torsensor_stTorSensorCof.uwBikeTorStep4RealNm =Syspara2.stSensorPara.uwBikeTor4StepRealNm.uwReal ;// I2C_uwSensorRead[12];
                torsensor_stTorSensorCof.uwBikeTorStep4ADC = Syspara2.stSensorPara.uwBikeTor4StepADC.uwReal ;//I2C_uwSensorRead[13];
                cadence_stFreGetCof.uwTorque_NumbersPulses = Syspara2.stSensorPara.uwTorque_SensorPulseNm.uwReal ;//I2C_uwSensorRead[14];
                bikespeed_stFreGetCof.uwNumbersPulses =Syspara2.stSensorPara.uwBikeSpdSensorPulseNm.uwReal ;// I2C_uwSensorRead[15];
		cadence_stFreGetCof.uwCad_NumbersPulses =Syspara2.stSensorPara.uwCad_SensorPulseNm.uwReal;// I2C_uwSensorRead[16];
            }
            else
            {
                cp_stFlg.RunPermitFlg = FALSE;
            }
            if (i2c_stRXCRCOut.blAssistParaFltFlg == FALSE)
            {
                ass_ParaSet.uwStartupCoef = Syspara2.stAssistPara.uwStartupGain.uwReal ;//I2C_uwAssistParaRead[0];
                ass_ParaSet.uwStartupCruiseCoef =Syspara2.stAssistPara.uwStartcruiseGain.uwReal ;// I2C_uwAssistParaRead[1];
                ass_ParaSet.uwAssistStartNm =Syspara2.stAssistPara.uwAssistStartNm.uwReal ;// I2C_uwAssistParaRead[2];
                ass_ParaSet.uwAssistStopNm =Syspara2.stAssistPara.uwAssistStopNm.uwReal ;// I2C_uwAssistParaRead[3];
                ass_ParaSet.uwStartUpGainStep =Syspara2.stAssistPara.uwStartUpGainStep.uwReal ;// I2C_uwAssistParaRead[4];
                ass_ParaSet.uwStartUpCadNm =Syspara2.stAssistPara.uwStartUpCadNm.uwReal ;// I2C_uwAssistParaRead[5];
                ass_ParaSet.uwTorLPFCadNm =Syspara2.stAssistPara.uwTorLPFCadNm.uwReal ;// I2C_uwAssistParaRead[6];
                ass_ParaSet.uwSpeedAssistSpdRpm =Syspara2.stAssistPara.uwSpeedAssistSpdRpm.uwReal ;// I2C_uwAssistParaRead[7];
                ass_ParaSet.uwSpeedAssistIMaxA =Syspara2.stAssistPara.uwSpeedAssistIMaxA.uwReal ;// I2C_uwAssistParaRead[8];
                ass_ParaSet.uwAssistLimitBikeSpdStart =Syspara2.stAssistPara.uwAssistLimitBikeSpdStart.uwReal ;// I2C_uwAssistParaRead[9];
                ass_ParaSet.uwAssistLimitBikeSpdStop =Syspara2.stAssistPara.uwAssistLimitBikeSpdStop.uwReal ;// I2C_uwAssistParaRead[10];
                ass_ParaSet.uwCadenceWeight =Syspara2.stAssistPara.uwCadenceAssistWeight.uwReal ;// I2C_uwAssistParaRead[11];
                ass_stCadAssSpdCtl.uwPidKp =Syspara2.stAssistPara.uwCadenceAssKp.uwReal ;// I2C_uwAssistParaRead[12];
                ass_stCadAssSpdCtl.swPidLimMax =Syspara2.stAssistPara.swCadenceVolStep.swReal ;// I2C_uwAssistParaRead[13];
                ass_stCadAssSpdCtl.swPidVolDec =Syspara2.stAssistPara.swCadenceVolDecStep.swReal ;// I2C_uwAssistParaRead[14];
                ass_stCadAssParaPro.swTargetAssCurAcc =Syspara2.stAssistPara.swCadenceCurStep.swReal ;// I2C_uwAssistParaRead[15];
                ass_stCadAssCoef.uwMaxCadRpm =Syspara2.stAssistPara.uwMaxCadRpm.uwReal ;// I2C_uwAssistParaRead[16];
                ass_stReservePara.uwReserve2 =Syspara2.stAssistPara.uwReserve2.uwReal ;// I2C_uwAssistParaRead[17];
                ass_stReservePara.uwReserve3 =Syspara2.stAssistPara.uwReserve3.uwReal ;// I2C_uwAssistParaRead[18];
                ass_stReservePara.uwReserve4 =Syspara2.stAssistPara.uwReserve4.uwReal ;// I2C_uwAssistParaRead[19];
            }
            else
            {}
            if (i2c_stRXCRCOut.blBikePara2FltFlg == FALSE)
                {
                    ass_ParaCong.uwNoneOBCEnable =    Syspara2.stBikePara2.uwNoneOBCEnable.uwReal ;// I2C_uwBikePara2Read[0];
                    ass_ParaCong.uwRearLightCycle =Syspara2.stBikePara2.uwRearLightCycle.uwReal;// I2C_uwBikePara2Read[1];
                    ass_ParaCong.uwRearLightDuty = Syspara2.stBikePara2.uwRearLightDuty.uwReal  ;//I2C_uwBikePara2Read[2];
                    ass_ParaCong.swDeltaBikeSpeedLimit =Syspara2.stBikePara2.swDeltaBikeSpeedLimit.swReal;// (SWORD) I2C_uwBikePara2Read[3];
                }
                else
                {}
      }
//      mn_voControlPareSet();
      cp_stFlg.ParaUseEEFinishFlg = TRUE;
    }
    else
    {}
}
void mn_voControlPareSet(void)
{
    if (cp_stFlg.ParaUseEEFlg == TRUE)
    {
        cp_stFlg.RunModelSelect = Syspara2.flash_stPara.stTestParaInfo.RunModelSelect;
        cp_stFlg.ThetaGetModelSelect = Syspara2.flash_stPara.stTestParaInfo.ThetaGetModelSelect;
        cp_stFlg.CurrentSampleModelSelect = Syspara2.flash_stPara.stTestParaInfo.CurrentSampleModelSelect;
        cp_stFlg.RotateDirectionSelect = Syspara2.flash_stPara.stTestParaInfo.RotateDirectionSelect;
        cp_stControlPara.swAlignCurAp = Syspara2.flash_stPara.stTestParaInfo.uwInitPosCurAmp;
        cp_stControlPara.swDragVolAp = Syspara2.flash_stPara.stTestParaInfo.uwVFControlVolAmp;
        cp_stControlPara.swDragCurAp = Syspara2.flash_stPara.stTestParaInfo.uwIFControlCurAmp;
        cp_stControlPara.swDragSpdHz = Syspara2.flash_stPara.stTestParaInfo.uwVFIFTargetFreHz;
        cp_stControlPara.swSpeedAccRate = Syspara2.flash_stPara.stTestParaInfo.uwSpeedLoopAccRate;
        cp_stControlPara.swSpeedDccRate =Syspara2.flash_stPara.stTestParaInfo.uwSpeedLoopDecRate;
        cp_stControlPara.swAsrPIBandwidth = Syspara2.flash_stPara.stTestParaInfo.uwSpeedLoopBandWidthHz;
        cp_stControlPara.swAsrPIM = Syspara2.flash_stPara.stTestParaInfo.uwSpeedLoopCoefM;
        cp_stControlPara.swAcrPIBandwidth = Syspara2.flash_stPara.stTestParaInfo.uwCuerrentLoopBandWidthHz;
        cp_stControlPara.swAcrRaCoef = Syspara2.flash_stPara.stTestParaInfo.uwCurrentLoopCoefM;
        cp_stControlPara.swObsFluxPIDampratio =Syspara2.flash_stPara.stTestParaInfo.uwFluxObsCoefM ;
        cp_stControlPara.swObsFluxPICrossfreHz =Syspara2.flash_stPara.stTestParaInfo.uwFluxObsBandWidthHz ;
        cp_stControlPara.swObsSpdPLLM = Syspara2.flash_stPara.stTestParaInfo.uwThetaObsPLLCoefM;
        cp_stControlPara.swObsSpdPLLBandWidthHz = Syspara2.flash_stPara.stTestParaInfo.uwThetaObsPLLBandWidthHz;
        cp_stControlPara.swPWMMaxDuty = Syspara2.flash_stPara.stTestParaInfo.uwPWMMaxDuty;
        cp_stControlPara.swPWM7to5Duty = Syspara2.flash_stPara.stTestParaInfo.uwPWM7to5Duty;
        cp_stControlPara.swPwrLimitValWt = Syspara2.flash_stPara.stTestParaInfo.uwPwrLimit;
        cp_stControlPara.swPwrLimitErrWt = Syspara2.flash_stPara.stTestParaInfo.uwPwrLimitError;
        cp_stControlPara.swPwrLimitKpPu = Syspara2.flash_stPara.stTestParaInfo.uwPwrLimitKp;
        cp_stControlPara.swPwrLimitKiPu = Syspara2.flash_stPara.stTestParaInfo.uwPwrLimitKi;
    }
}

/***************************************************************
 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.ParaUpdateFlg == TRUE)
    {
        if (cp_stFlg.ParaMInfoUpdateFlg == TRUE)
        {
            cp_stMotorPara.swMotrPolePairs = MC_UpcInfo.stMotorInfo.uwPolePairs;
            cp_stMotorPara.swRsOhm = MC_UpcInfo.stMotorInfo.uwRsmOhm;
            cp_stMotorPara.uwLdmH = MC_UpcInfo.stMotorInfo.uwLduH;
            cp_stMotorPara.uwLqmH = MC_UpcInfo.stMotorInfo.uwLquH;
            cp_stMotorPara.swFluxWb = MC_UpcInfo.stMotorInfo.uwFluxmWb;
            cp_stMotorPara.swIdMaxA = MC_UpcInfo.stMotorInfo.uwIdMaxA;
            cp_stMotorPara.swIdMinA = MC_UpcInfo.stMotorInfo.uwIdMinA;
            cp_stMotorPara.swRSpeedRpm = MC_UpcInfo.stMotorInfo.uwRSpdRpm;
            cp_stMotorPara.uwRPwrWt = MC_UpcInfo.stMotorInfo.uwRPwrWt;
            cp_stMotorPara.swRIarmsA = MC_UpcInfo.stMotorInfo.uwRCurA;
            cp_stMotorPara.swRUdcV = MC_UpcInfo.stMotorInfo.uwRVolV;
            cp_stMotorPara.swJD = MC_UpcInfo.stMotorInfo.uwJD;
            cp_stMotorPara.swTorMax = MC_UpcInfo.stMotorInfo.uwTorMaxNm;

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

        if (cp_stFlg.ParaBikeInfoUpdateFlg == TRUE)
        {
            ass_ParaCong.uwWheelPerimeter = MC_UpcInfo.stBikeInfo.uwWheelPerimeter;
            ass_ParaCong.uwMechRationMotorEEPROM=MC_UpcInfo.stBikeInfo.uwMechRationMotor;
            ass_ParaCong.uwMechRationMotor = (UWORD)(((ULONG)ass_ParaCong.uwMechRationMotorEEPROM*1024)/1000);
            ass_ParaCong.uwThrottleMaxSpdKmH = MC_UpcInfo.stBikeInfo.uwThrottleMaxSpdKmH;
            ass_ParaCong.uwCartSpdKmH = MC_UpcInfo.stBikeInfo.uwCartSpdKmH;
            ass_ParaCong.uwNmFrontChainring = MC_UpcInfo.stBikeInfo.uwNmFrontChainring;
            ass_ParaCong.uwNmBackChainring = MC_UpcInfo.stBikeInfo.uwNmBackChainring;
            ass_ParaCong.uwAssistSelect1 = MC_UpcInfo.stBikeInfo.uwAssistSelect1;
            ass_ParaCong.uwAssistSelect2 = MC_UpcInfo.stBikeInfo.uwAssistSelect2;
            ass_ParaCong.uwLightConfig = MC_UpcInfo.stBikeInfo.uwLightConfig;
            ass_ParaCong.swDeltPerimeter = MC_UpcInfo.stBikeInfo.swWheelSizeAdjust;
            ass_ParaCong.uwStartMode = MC_UpcInfo.stBikeInfo.uwStartMode;
            ass_ParaCong.uwAutoPowerOffTime = MC_UpcInfo.stBikeInfo.uwAutoPowerOffTime;

            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 = MC_UpcInfo.stMContorlInfo.uwIPeakMaxA;
            cp_stControlPara.swAlmOverCurrentVal = MC_UpcInfo.stMContorlInfo.uwAlamOCurA;
            cp_stControlPara.swAlmOverVolVal1 = MC_UpcInfo.stMContorlInfo.uwAlamOVolV;
            cp_stControlPara.swAlmUnderVolVal1 = MC_UpcInfo.stMContorlInfo.uwAlamUVolV;
            cp_stControlPara.swAlmOverSpdVal = MC_UpcInfo.stMContorlInfo.uwAlamOverSpdRpm;
            cp_stControlPara.swAlmOverHeatCeVal = MC_UpcInfo.stMContorlInfo.uwAlamOverHeatCe;
            cp_stControlPara.swAlmRecOHeatVal = MC_UpcInfo.stMContorlInfo.uwAlamRecHeatCe;
            cp_stControlPara.swAlmPwrLimitStartTempVal = 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;
            cp_stControlPara.uwControlFunEN=MC_UpcInfo.stMContorlInfo.uwControlFunEN;

            cp_stControlPara.swAlmRecOVVal=cp_stControlPara.swAlmOverVolVal1-10; //过压恢复值
            cp_stControlPara.swAlmRecUVVal=cp_stControlPara.swAlmUnderVolVal1+10;//欠压恢复值
            cp_stControlPara.swCvbConstantVolBrakeV=cp_stControlPara.swAlmRecOVVal;
            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.uwTorque_NumbersPulses = MC_UpcInfo.stSensorInfo.uwTorque_SensorPulseNm;
            bikespeed_stFreGetCof.uwNumbersPulses = MC_UpcInfo.stSensorInfo.uwBikeSpdSensorPulseNm;
            cadence_stFreGetCof.uwCad_NumbersPulses=MC_UpcInfo.stSensorInfo.uwCad_SensorPulseNm;

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

        if (cp_stFlg.ParaAInfoUpdateFlg == TRUE)
        {
            ass_ParaSet.uwStartupCoef = MC_UpcInfo.stAssistInfo.swStartupGain;
            ass_ParaSet.uwStartupCruiseCoef = MC_UpcInfo.stAssistInfo.swStartcruiseGain;
            ass_ParaSet.uwAssistStartNm = MC_UpcInfo.stAssistInfo.uwAssistStartNm;
            ass_ParaSet.uwAssistStopNm = MC_UpcInfo.stAssistInfo.uwAssistStopNm;
            ass_ParaSet.uwStartUpGainStep = MC_UpcInfo.stAssistInfo.uwStartUpGainStep;
            ass_ParaSet.uwStartUpCadNm = MC_UpcInfo.stAssistInfo.uwStartUpCadNm;
            ass_ParaSet.uwTorLPFCadNm = MC_UpcInfo.stAssistInfo.uwTorLPFCadNm;
            ass_ParaSet.uwSpeedAssistSpdRpm = MC_UpcInfo.stAssistInfo.uwSpeedAssistSpdRpm;
            ass_ParaSet.uwSpeedAssistIMaxA = MC_UpcInfo.stAssistInfo.uwSpeedAssistIMaxA;
            ass_ParaSet.uwAssistLimitBikeSpdStart = MC_UpcInfo.stAssistInfo.uwAssistLimitBikeSpdStart;
            ass_ParaSet.uwAssistLimitBikeSpdStop = MC_UpcInfo.stAssistInfo.uwAssistLimitBikeSpdStop;
            ass_ParaSet.uwCadenceWeight = MC_UpcInfo.stAssistInfo.uwCadenceAssistWeight;
            ass_stCadAssSpdCtl.uwPidKp = MC_UpcInfo.stAssistInfo.uwCadAssPidKp;
            ass_stCadAssSpdCtl.swPidLimMax = MC_UpcInfo.stAssistInfo.swCadAssPidLimMax;
            ass_stCadAssSpdCtl.swPidVolDec = MC_UpcInfo.stAssistInfo.swCadAssPidVolDec;
            ass_stCadAssParaPro.swTargetAssCurAcc = MC_UpcInfo.stAssistInfo.swCadAssTargetAssCurAcc;
            ass_stCadAssCoef.uwMaxCadRpm = MC_UpcInfo.stAssistInfo.uwMaxCadRpm;
            ass_stReservePara.uwReserve2 = MC_UpcInfo.stAssistInfo.reserve2;
            ass_stReservePara.uwReserve3 = MC_UpcInfo.stAssistInfo.reserve3;
            ass_stReservePara.uwReserve4 = MC_UpcInfo.stAssistInfo.reserve4;

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

        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_stControlPara.swAlignCurAp = MC_UpcInfo.stTestParaInfo.uwInitPosCurAmp;
            cp_stControlPara.swDragVolAp = MC_UpcInfo.stTestParaInfo.uwVFControlVolAmp;
            cp_stControlPara.swDragCurAp = MC_UpcInfo.stTestParaInfo.uwIFControlCurAmp;
            cp_stControlPara.swDragSpdHz = MC_UpcInfo.stTestParaInfo.uwVFIFTargetFreHz;

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

            cp_stControlPara.swAcrPIBandwidth = MC_UpcInfo.stTestParaInfo.uwCuerrentLoopBandWidthHz;
            cp_stControlPara.swAcrRaCoef = MC_UpcInfo.stTestParaInfo.uwCurrentLoopCoefM;

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

            cp_stMotorPara.swJD = MC_UpcInfo.stTestParaInfo.uwJm;
            cp_stControlPara.swPWMMaxDuty = MC_UpcInfo.stTestParaInfo.uwPWMMaxDuty;
            cp_stControlPara.swPWM7to5Duty = MC_UpcInfo.stTestParaInfo.uwPWM7to5Duty;
            cp_stControlPara.swPwrLimitValWt = MC_UpcInfo.stTestParaInfo.uwPwrLimit;
            cp_stControlPara.swPwrLimitErrWt = MC_UpcInfo.stTestParaInfo.uwPwrLimitError;
            cp_stControlPara.swPwrLimitKpPu = MC_UpcInfo.stTestParaInfo.uwPwrLimitKp;
            cp_stControlPara.swPwrLimitKiPu = 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_ParaCong.uwNoneOBCEnable = MC_UpcInfo.stBikeInfo2.uwNoneOBCEnable;
               ass_ParaCong.uwRearLightCycle = MC_UpcInfo.stBikeInfo2.uwRearLightCycle;
               ass_ParaCong.uwRearLightDuty = MC_UpcInfo.stBikeInfo2.uwRearLightDuty;
               ass_ParaCong.swDeltaBikeSpeedLimit = MC_UpcInfo.stBikeInfo2.swDeltaBikeSpeedLimit;

               cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
               cp_stFlg.ParaBikeInfo2UpdateFlg = FALSE;
           }
        cp_stFlg.ParaUpdateFlg = FALSE;
    }
}


/***************************************************************
 Function: mn_voEEUperParaUpdate;
 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 = cp_stMotorPara.swMotrPolePairs;
        Syspara2.stMotorPara.uwRsmOhm.uwReal = cp_stMotorPara.swRsOhm;
        Syspara2.stMotorPara.uwLduH.uwReal = cp_stMotorPara.uwLdmH;
        Syspara2.stMotorPara.uwLquH.uwReal = cp_stMotorPara.uwLqmH;
        Syspara2.stMotorPara.uwFluxmWb.uwReal = cp_stMotorPara.swFluxWb;
        Syspara2.stMotorPara.uwIdMaxA.uwReal = cp_stMotorPara.swIdMaxA;
        Syspara2.stMotorPara.uwIdMinA.uwReal = cp_stMotorPara.swIdMinA;
        Syspara2.stMotorPara.uwRSpdRpm.uwReal = cp_stMotorPara.swRSpeedRpm;
        Syspara2.stMotorPara.uwRPwrWt.uwReal = cp_stMotorPara.uwRPwrWt;
        Syspara2.stMotorPara.uwRCurA.uwReal = cp_stMotorPara.swRIarmsA;
        Syspara2.stMotorPara.uwRVolV.uwReal = cp_stMotorPara.swRUdcV;
        Syspara2.stMotorPara.uwJD.uwReal = cp_stMotorPara.swJD;
        Syspara2.stMotorPara.uwTorMaxNm.uwReal = cp_stMotorPara.swTorMax;
    }
    Syspara2.stBikePara.swDeltPerimeter.swReal = ass_ParaCong.swDeltPerimeter;
    if (MC_UpcInfo.stBikeInfo.uwSaveFlg == TRUE)
    {
        Syspara2.stBikePara.uwWheelPerimeter.uwReal = ass_ParaCong.uwWheelPerimeter;
        Syspara2.stBikePara.swDeltPerimeter.swReal = ass_ParaCong.swDeltPerimeter;
        Syspara2.stBikePara.uwMechRationMotor.uwReal= ass_ParaCong.uwMechRationMotorEEPROM;
        //Syspara2.stBikePara.uwMechRationMotor.uwReal = (UWORD)(((ULONG)ass_ParaCong.uwMechRationMotor*1000)/1024);
        Syspara2.stBikePara.uwThrottleMaxSpdKmH.uwReal = ass_ParaCong.uwThrottleMaxSpdKmH;
        Syspara2.stBikePara.uwCartSpdKmH.uwReal = ass_ParaCong.uwCartSpdKmH;
        Syspara2.stBikePara.uwNmFrontChainring.uwReal = ass_ParaCong.uwNmFrontChainring;
        Syspara2.stBikePara.uwNmBackChainring.uwReal = ass_ParaCong.uwNmBackChainring;
        Syspara2.stBikePara.uwAssistSelect1.uwReal = ass_ParaCong.uwAssistSelect1;
        Syspara2.stBikePara.uwAssistSelect2.uwReal = ass_ParaCong.uwAssistSelect2;
        Syspara2.stBikePara.uwLightConfig.uwReal = ass_ParaCong.uwLightConfig;
        Syspara2.stBikePara.uwStartMode.uwReal = ass_ParaCong.uwStartMode;
        Syspara2.stBikePara.uwAutoPowerOffTime.uwReal = ass_ParaCong.uwAutoPowerOffTime;
    }
    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 = cp_stMotorPara.swIpeakMaxA;
        Syspara2.stMControlPara.uwAlamOCurA.uwReal = cp_stControlPara.swAlmOverCurrentVal;
        Syspara2.stMControlPara.uwAlamOVolV.uwReal = cp_stControlPara.swAlmOverVolVal1;
        Syspara2.stMControlPara.uwAlamUVolV.uwReal = cp_stControlPara.swAlmUnderVolVal1;
        Syspara2.stMControlPara.uwAlamOverSpdRpm.uwReal = cp_stControlPara.swAlmOverSpdVal;
        Syspara2.stMControlPara.uwAlamOverHeatCe.uwReal = cp_stControlPara.swAlmOverHeatCeVal;
        Syspara2.stMControlPara.uwAlamRecHeatCe.uwReal = cp_stControlPara.swAlmRecOHeatVal;
        Syspara2.stMControlPara.uwPwrLimitStartCe.uwReal = cp_stControlPara.swAlmPwrLimitStartTempVal;
        Syspara2.stMControlPara.uwAlamMotorOverHeatCe.uwReal = cp_stControlPara.swAlmMotorOverHeatCeVal;
        Syspara2.stMControlPara.uwAlamMotorRecHeatCe.uwReal = cp_stControlPara.swAlmMotorRecOHeatVal;
        Syspara2.stMControlPara.uwPwrLimitMotorStartCe.uwReal = cp_stControlPara.swAlmPwrLimitMotorStartTempVal;
        Syspara2.stMControlPara.uwControlFunEN.uwReal=cp_stControlPara.uwControlFunEN;
    }
    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.uwTorque_SensorPulseNm.uwReal = cadence_stFreGetCof.uwTorque_NumbersPulses;
        Syspara2.stSensorPara.uwBikeSpdSensorPulseNm.uwReal = bikespeed_stFreGetCof.uwNumbersPulses;
        Syspara2.stSensorPara.uwCad_SensorPulseNm.uwReal= cadence_stFreGetCof.uwCad_NumbersPulses;
    }
    if (MC_UpcInfo.stTestParaInfo.uwSaveFlg == TRUE )
    {
        memcpy(&Syspara2.flash_stPara.stTestParaInfo.uwTestParaSaveFlg, &MC_UpcInfo.stTestParaInfo.uwTestParaSaveFlg, sizeof(Syspara2.flash_stPara.stTestParaInfo));
    }
    if (MC_UpcInfo.stAssistInfo.uwSaveFlg == TRUE)
    {
        Syspara2.stAssistPara.uwStartupGain.uwReal = ass_ParaSet.uwStartupCoef;
        Syspara2.stAssistPara.uwStartcruiseGain.uwReal = ass_ParaSet.uwStartupCruiseCoef;
        Syspara2.stAssistPara.uwAssistStartNm.uwReal = ass_ParaSet.uwAssistStartNm;
        Syspara2.stAssistPara.uwAssistStopNm.uwReal = ass_ParaSet.uwAssistStopNm;
        Syspara2.stAssistPara.uwStartUpGainStep.uwReal = ass_ParaSet.uwStartUpGainStep;
        Syspara2.stAssistPara.uwStartUpCadNm.uwReal = ass_ParaSet.uwStartUpCadNm;
        Syspara2.stAssistPara.uwTorLPFCadNm.uwReal = ass_ParaSet.uwTorLPFCadNm;
        Syspara2.stAssistPara.uwSpeedAssistSpdRpm.uwReal = ass_ParaSet.uwSpeedAssistSpdRpm;
        Syspara2.stAssistPara.uwSpeedAssistIMaxA.uwReal = ass_ParaSet.uwSpeedAssistIMaxA;
        Syspara2.stAssistPara.uwAssistLimitBikeSpdStart.uwReal = ass_ParaSet.uwAssistLimitBikeSpdStart;
        Syspara2.stAssistPara.uwAssistLimitBikeSpdStop.uwReal = ass_ParaSet.uwAssistLimitBikeSpdStop;
        Syspara2.stAssistPara.uwCadenceAssistWeight.uwReal = ass_ParaSet.uwCadenceWeight;
        Syspara2.stAssistPara.uwCadenceAssKp.uwReal = ass_stCadAssSpdCtl.uwPidKp;
        Syspara2.stAssistPara.swCadenceVolStep.swReal = ass_stCadAssSpdCtl.swPidLimMax;
        Syspara2.stAssistPara.swCadenceVolDecStep.swReal = ass_stCadAssSpdCtl.swPidVolDec;
        Syspara2.stAssistPara.swCadenceCurStep.swReal = ass_stCadAssParaPro.swTargetAssCurAcc;
        Syspara2.stAssistPara.uwMaxCadRpm.uwReal = ass_stCadAssCoef.uwMaxCadRpm;
        Syspara2.stAssistPara.uwReserve2.uwReal = ass_stReservePara.uwReserve2;
        Syspara2.stAssistPara.uwReserve3.uwReal = ass_stReservePara.uwReserve3;
        Syspara2.stAssistPara.uwReserve4.uwReal = ass_stReservePara.uwReserve4;

    }
}
/***************************************************************
 Function: mn_voEEHistoryParaUpdate;
 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)
{
    stHistoryPara.uwAssModSelect.uwReal = ass_ParaSet.uwAsssistSelectNum;
    stHistoryPara.uwOpenTimes.uwReal = cp_stHistoryPara.uwOpenTimes;
    stHistoryPara.uwUsedTimeH.uwReal = (UWORD)(cp_stHistoryPara.ulUsedTime >> 16);
    stHistoryPara.uwUsedTimeL.uwReal = (UWORD)cp_stHistoryPara.ulUsedTime;
    stHistoryPara.swNTCTempMaxCe.swReal = cp_stHistoryPara.swNTCTempMaxCe;
    stHistoryPara.swNTCTempMinCe.swReal = cp_stHistoryPara.swNTCTempMinCe;

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

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

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

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

    stHistoryPara.uwTorSensorAlamTimes.uwReal = cp_stHistoryPara.uwTorSensorAlamTimes;
    stHistoryPara.uwCadSensorAlamTimes.uwReal = cp_stHistoryPara.uwCadSensorAlamTimes;
    stHistoryPara.uwBikeSpdSensorAlamTimes.uwReal = cp_stHistoryPara.uwBikeSpdSensorAlamTimes;
    stHistoryPara.uwPosSensorAlamTimes.uwReal = cp_stHistoryPara.uwPosSensorAlamTimes;
    stHistoryPara.uwRealODOTripH.uwReal = (UWORD)(cp_stHistoryPara.ulRealODOTrip >> 16);
    stHistoryPara.uwRealODOTripL.uwReal = (UWORD)cp_stHistoryPara.ulRealODOTrip;
    stHistoryPara.uwRealODOTimeH.uwReal = (UWORD)(cp_stHistoryPara.ulRealODOTime >> 16);
    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];
        
    }
    if (MC_UpcInfo.stBikeInfo2.uwSaveFlg == TRUE)
     {
         Syspara2.stBikePara2.uwNoneOBCEnable.uwReal = (UWORD)ass_ParaCong.uwNoneOBCEnable;
         Syspara2.stBikePara2.uwRearLightCycle.uwReal = (UWORD)ass_ParaCong.uwRearLightCycle;
         Syspara2.stBikePara2.uwRearLightDuty.uwReal = (UWORD)ass_ParaCong.uwRearLightDuty;
         Syspara2.stBikePara2.swDeltaBikeSpeedLimit.swReal = (SWORD)ass_ParaCong.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();
    /* Event parameter init */
    event_voInit();
    /* Motor parameter init */
    //   mn_voMtParInit();
    /* PowerInit */
    power_voPowerInit();
    /* Control Parameters init */
    mn_voMcParInit();
    /*cmd handle Initial */
    cmd_voCmdInit();
    /* FSM init */
    FSM_voInit();
    RUN_FSM_voInit();
    Switch_speed_FSMInit();
    
    /* TempInit */
    TempInit();
        
    /* BikeSpeedInit */
    bikespeed_voBikeSpeedInit();
    /* CadenceInit */
    cadence_voCadenceInit();
    
    Can_voInitMC_Run();
    mn_voControlPareSet();
    /* Alarm init */
    alm_voCoef();
    /* ADC init */
    adc_voSampleInit();
    adc_voSampleCoef(&adc_stCof);
    /* UART init */
    //uart_voMonitorInit();
    
    //profiler_init();
}

/************************************************************************
 Function: void mn_voMtParInit(void)
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
************************************************************************/
void mn_voMtParInit(void)
{
    mn_swIdTurn1Pu = ((SLONG)M_LD_TURN1_ID_AP << 14) / 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 = ((SLONG)M_LD_TURN2_ID_AP << 14) / 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 = ((mn_slLdTurn2Pu - mn_slLdTurn1Pu) << 10) / (mn_swIdTurn2Pu - mn_swIdTurn1Pu); // Q10
    }

    mn_swIqTurn1Pu = ((SLONG)M_LQ_TURN1_IQ_AP << 14) / 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 = ((SLONG)M_LQ_TURN2_IQ_AP << 14) / 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 = ((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 = 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 = CUR_AP2PU(cp_stControlPara.swDragCurAp); // Q14
    mn_uwDragSpdPu = 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_uwDragSpdPu << 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_uwStopSpdRefPu = SPD_RPM2PU(cp_stControlPara.swStopSpdRefRpm);
}
void LED_ResDispaly(void)
{
    uint32_t icnt;
    for(icnt=0;icnt<3;icnt++)
    {
        IO_FORWARDLED_ON();
        delay_125us(2000);
        IO_FORWARDLED_OFF();//关前灯
        delay_125us(2000);
    }
}

/*************************************************************************
 Copyright (c) 2018 Welling Motor Technology(Shanghai) Co. Ltd.
 All rights reserved.
*************************************************************************/
#ifdef _MAIN_C_
#undef _MAIN_C_
#endif
/*************************************************************************
 End of this File (EOF)!
 Do not put anything after this part!
*************************************************************************/