/** * @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;iVTOR =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)) DL_COMP_setDACCode0(COMP_0_INST, 0xC7);//12G-100A-0x99-1.97V 6G-70A--0xb5-2.33V #else DL_COMP_setDACCode0(COMP_0_INST, 0x99);//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.swRPwrWt = 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]; } 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.swRPwrWt = 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_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.swRPwrWt; 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! *************************************************************************/