motor_ctl-4/User project/3.BasicFunction/Source/canAppl.c

/**
 * @file canAppl.c
 * @author Zhang, Kai(zhangkai71@midea.com)
 * @brief
 * @version 0.1
 * @date 2022-03-02
 *
 * @copyright Copyright (c) 2022
 *
 */

/******************************
 *
 *  Include Files
 *
 ******************************/
#include "canAppl.h"
#include "syspar.h"
#include "user.h"
#include "CodePara.h"
#include "can.h"
#include "flash_master.h"
#include "AssistCurve.h"
#include "spi_master.h"
#include "torquesensor.h"
#include "FSM_1st.h"
#include "FSM_2nd.h"
#include "sys_ctrl.h"
#include "string.h"
//#include "hwsetup.h"
#include "fp.def"
#include "queue.h"
#include "api.h"
#include "bikethrottle.h"
/******************************
 *
 *  Parameter
 *
 ******************************/
MC_RunInfo_Struct_t              MC_RunInfo;
MC_ErrorCode_Struct_t            MC_ErrorCode = CAN_MC_ALARMCODE_DEFAULT;
MC_ErrorCode_CNT_RECORD_Struct_t MC_ErrorCntRecord = CAN_MC_ALARMCODE_CNT_RECORD_DEFAULT;
MC_VerInfo_Struct_t              MC_VerInfo;
char                             Firmware_Special[32];
MC_MacInfo_Struct_t              MC_MacInfo;
MC_RideLog_Struct_t              MC_RideLog;
BMS_RunInfo_Struct_t             BMS_RunInfo;
MC_ControlCode_Struct_t          MC_ControlCode;
MC_RunInfoToCDL_Struct_t         MC_RunInfoToCDL;
MC_RS_ASCII_Struct_t             MC_RsASSCII;
MC_UpperPCInfo_Struct_t          MC_UpcInfo;
BMS_VoltEstimat_Struct_t         BMS_VoltEstimat;

OBC_SetCustomPara_Struct_t OBC_SetCustomPara;
OBC_ButtonStatus_Struct_t  OBC_ButtonStatus = {0, 0, 0};
ULONG                      ulOBC_ComTimeOutCount = 0;
ULONG                      ulBMS_ComTimeOutCount = 0;
UBYTE                    MC_MotorSPD_rpm_Percent = 0;
UBYTE                    MC_WorkMode;
UBYTE                    MC_BC_COM = 0;
static LPF_OUT                    BMS_swCurIdcLpf;
BOOL blBMSCommFault = FALSE;
static UWORD uwRemainDistanceCal;
UWORD  ulPowerOnUsedTime = 0;
BOOL AngleTest = FALSE;

static SLONG slBMSMaxVol = 42000;
static SLONG slBMSMinVol = 32000;
void Can_voUpdateMC_UpcInfo(void)
{
    MC_UpcInfo.stMotorInfo.uwPolePairs = cp_stMotorPara.swMotrPolePairs;
    MC_UpcInfo.stMotorInfo.uwRsmOhm = cp_stMotorPara.swRsOhm;
    MC_UpcInfo.stMotorInfo.uwLduH = cp_stMotorPara.swLdmH;
    MC_UpcInfo.stMotorInfo.uwLquH = cp_stMotorPara.swLqmH;
    MC_UpcInfo.stMotorInfo.uwFluxmWb = cp_stMotorPara.swFluxWb;
    MC_UpcInfo.stMotorInfo.uwIdMaxA = cp_stMotorPara.swIdMaxA;
    MC_UpcInfo.stMotorInfo.uwIdMinA = cp_stMotorPara.swIdMinA;
    MC_UpcInfo.stMotorInfo.uwRSpdRpm = cp_stMotorPara.swRSpeedRpm;
    MC_UpcInfo.stMotorInfo.uwRPwrWt = cp_stMotorPara.swRPwrWt;
    MC_UpcInfo.stMotorInfo.uwRCurA = cp_stMotorPara.swRIarmsA;
    MC_UpcInfo.stMotorInfo.uwRVolV = cp_stMotorPara.swRUdcV;
    MC_UpcInfo.stMotorInfo.uwJD = cp_stMotorPara.swJD;
    MC_UpcInfo.stMotorInfo.uwTorMaxNm = cp_stMotorPara.swTorMax;

    MC_UpcInfo.stBikeInfo.uwWheelPerimeter = ass_stParaCong.uwWheelPerimeter;
    MC_UpcInfo.stBikeInfo.uwMechRationMotor = ass_stParaCong.uwMechRationMotor;
    MC_UpcInfo.stBikeInfo.uwAssistMaxSpdKmH = ass_stParaCong.uwAssistMaxSpdKmH;
    MC_UpcInfo.stBikeInfo.uwThrottleMaxSpdKmH = ass_stParaCong.uwThrottleMaxSpdKmH;
    MC_UpcInfo.stBikeInfo.uwNmFrontChainring = ass_stParaCong.uwNmFrontChainring;
    MC_UpcInfo.stBikeInfo.uwNmBackChainring = ass_stParaCong.uwNmBackChainring;
    MC_UpcInfo.stBikeInfo.uwAssistSelect1 = ass_stParaCong.uwAssistSelect1;
    MC_UpcInfo.stBikeInfo.uwAssistSelect2 = ass_stParaCong.uwAssistSelect2;
    MC_UpcInfo.stBikeInfo.uwLightVoltage = ass_stParaCong.uwLightVoltage;
    MC_UpcInfo.stBikeInfo.swWheelSizeAdjust = ass_stParaCong.swDeltPerimeter;
    MC_UpcInfo.stBikeInfo.uwStartMode = ass_stParaCong.uwStartMode;
    MC_UpcInfo.stBikeInfo.uwAutoPowerOffTime = ass_stParaCong.uwAutoPowerOffTime;
    MC_UpcInfo.stBikeInfo.uwThrottleSmooth = ass_stParaCong.uwThrottleSmooth;

    MC_UpcInfo.stMContorlInfo.uwSPIPosOffsetOrigin = spi_stResolverOut.swSpiThetaOffsetOrignPu;
    MC_UpcInfo.stMContorlInfo.uwSPIPosOffsetNow = spi_stResolverOut.swSpiThetaOffsetPu;
    MC_UpcInfo.stMContorlInfo.uwIPeakMaxA = cp_stMotorPara.swIpeakMaxA;
    MC_UpcInfo.stMContorlInfo.uwAlamOCurA = cp_stControlPara.swAlmOverCurrentVal;
    MC_UpcInfo.stMContorlInfo.uwAlamOVolV = cp_stControlPara.swAlmOverVolVal3;
    MC_UpcInfo.stMContorlInfo.uwAlamUVolV = cp_stControlPara.swAlmUnderVolVal2;
    MC_UpcInfo.stMContorlInfo.uwAlamOverSpdRpm = cp_stControlPara.swAlmOverSpdVal;
    MC_UpcInfo.stMContorlInfo.uwAlamOverHeatCe = cp_stControlPara.swAlmOverHeatCeVal;
    MC_UpcInfo.stMContorlInfo.uwAlamRecHeatCe = cp_stControlPara.swAlmRecOHeatVal;
    MC_UpcInfo.stMContorlInfo.uwPwrLimitStartCe = cp_stControlPara.swAlmPwrLimitStartTempVal;

    MC_UpcInfo.stSensorInfo.uwTorSensorOffsetOrigin = torsensor_stTorSensorCof.uwTorqueOffsetOrign;
    MC_UpcInfo.stSensorInfo.uwTorSensorOffsetNow1 = torsensor_stTorSensorCof.uwTorqueOffsetNow1;
    MC_UpcInfo.stSensorInfo.uwTorSensorOffsetNow2 = torsensor_stTorSensorCof.uwTorqueOffsetNow2;
    MC_UpcInfo.stSensorInfo.uwTorSensorOffsetNow3 = torsensor_stTorSensorCof.uwTorqueOffsetNow3;
    MC_UpcInfo.stSensorInfo.uwTorSensorOffsetNow4 = torsensor_stTorSensorCof.uwTorqueOffsetNow4;
    MC_UpcInfo.stSensorInfo.uwBikeTorMaxNm = torsensor_stTorSensorCof.uwMaxSensorTorquePu;
    MC_UpcInfo.stSensorInfo.uwBikeTor1StepRealNm = torsensor_stTorSensorCof.uwBikeTorStep1RealNm;
    MC_UpcInfo.stSensorInfo.uwBikeTor1StepADC = torsensor_stTorSensorCof.uwBikeTorStep1ADC;
    MC_UpcInfo.stSensorInfo.uwBikeTor2StepRealNm = torsensor_stTorSensorCof.uwBikeTorStep2RealNm;
    MC_UpcInfo.stSensorInfo.uwBikeTor2StepADC = torsensor_stTorSensorCof.uwBikeTorStep2ADC;
    MC_UpcInfo.stSensorInfo.uwBikeTor3StepRealNm = torsensor_stTorSensorCof.uwBikeTorStep3RealNm;
    MC_UpcInfo.stSensorInfo.uwBikeTor3StepADC = torsensor_stTorSensorCof.uwBikeTorStep3ADC;
    MC_UpcInfo.stSensorInfo.uwBikeTor4StepRealNm = torsensor_stTorSensorCof.uwBikeTorStep4RealNm;
    MC_UpcInfo.stSensorInfo.uwBikeTor4StepADC = torsensor_stTorSensorCof.uwBikeTorStep4ADC;
    MC_UpcInfo.stSensorInfo.uwCadSensorPulseNm = cadence_stFreGetCof.uwNumbersPulses;
    MC_UpcInfo.stSensorInfo.uwBikeSpdSensorPulseNm = bikespeed_stFreGetCof.uwNumbersPulses;

    MC_UpcInfo.stAssistInfo.swStartupGain = ass_stParaSet.uwStartupCoef;
    MC_UpcInfo.stAssistInfo.swStartcruiseGain = ass_stParaSet.uwStartupCruiseCoef;
    MC_UpcInfo.stAssistInfo.uwAssistStartNm = ass_stParaSet.uwAssistStartNm;
    MC_UpcInfo.stAssistInfo.uwAssistStopNm = ass_stParaSet.uwAssistStopNm;
    MC_UpcInfo.stAssistInfo.uwStartUpGainStep = ass_stParaSet.uwStartUpGainStep;
    MC_UpcInfo.stAssistInfo.uwStartUpCadNm = ass_stParaSet.uwStartUpCadNm;
    MC_UpcInfo.stAssistInfo.uwTorLPFCadNm = ass_stParaSet.uwTorLPFCadNm;
    MC_UpcInfo.stAssistInfo.uwSpeedAssistSpdRpm = ass_stParaSet.uwSpeedAssistSpdRpm;
    MC_UpcInfo.stAssistInfo.uwSpeedAssistIMaxA = ass_stParaSet.uwSpeedAssistIMaxA;
    MC_UpcInfo.stAssistInfo.uwAssistLimitBikeSpdStart = ass_stParaSet.uwAssistLimitBikeSpdStart;
    MC_UpcInfo.stAssistInfo.uwAssistLimitBikeSpdStop = ass_stParaSet.uwAssistLimitBikeSpdStop;
    MC_UpcInfo.stAssistInfo.uwCadenceAssistWeight = ass_stParaSet.uwCadenceWeight;

    MC_UpcInfo.stHistoryInfo.uwOpenTimes = cp_stHistoryPara.uwOpenTimes;
    MC_UpcInfo.stHistoryInfo.uwUsedTimeH = (UWORD)(cp_stHistoryPara.ulUsedTime >> 16);
    MC_UpcInfo.stHistoryInfo.uwUsedTimeL = (UWORD)(cp_stHistoryPara.ulUsedTime);
    MC_UpcInfo.stHistoryInfo.uwNTCTempMaxCe = cp_stHistoryPara.uwNTCTempMaxCe;
    MC_UpcInfo.stHistoryInfo.uwNTCTempMinCe = cp_stHistoryPara.uwNTCTempMinCe;
    ;

    MC_UpcInfo.stHistoryInfo.uwAlamHOcurTimes = cp_stHistoryPara.uwAlamHOcurTimes;
    MC_UpcInfo.stHistoryInfo.uwAlamSOcurTimes = cp_stHistoryPara.uwAlamSOcurTimes;
    MC_UpcInfo.stHistoryInfo.uwAlamOHeatTimes = cp_stHistoryPara.uwAlamOHeatTimes;
    MC_UpcInfo.stHistoryInfo.uwAlamRotorLockTimes = cp_stHistoryPara.uwAlamRotorLockTimes;
    MC_UpcInfo.stHistoryInfo.uwAlamPhsLossTimes = cp_stHistoryPara.uwAlamPhsLossTimes;
    MC_UpcInfo.stHistoryInfo.uwAlamOVolTimes = cp_stHistoryPara.uwAlamOVolTimes;
    MC_UpcInfo.stHistoryInfo.uwAlamUVolTimes = cp_stHistoryPara.uwAlamUVolTimes;
    MC_UpcInfo.stHistoryInfo.uwAlamComOTimeTimes = cp_stHistoryPara.uwAlamComOTimeTimes;

    MC_UpcInfo.stHistoryInfo.uwG1AvgPwrConsumption = cp_stHistoryPara.uwG1AvgPwrConsumption;
    MC_UpcInfo.stHistoryInfo.uwG2AvgPwrConsumption = cp_stHistoryPara.uwG2AvgPwrConsumption;
    MC_UpcInfo.stHistoryInfo.uwG3AvgPwrConsumption = cp_stHistoryPara.uwG3AvgPwrConsumption;
    MC_UpcInfo.stHistoryInfo.uwG4AvgPwrConsumption = cp_stHistoryPara.uwG4AvgPwrConsumption;
    MC_UpcInfo.stHistoryInfo.uwG5AvgPwrConsumption = cp_stHistoryPara.uwG5AvgPwrConsumption;

    MC_UpcInfo.stHistoryInfo.uwODOTripH = (UWORD)(cp_stHistoryPara.ulODOTrip >> 16);
    MC_UpcInfo.stHistoryInfo.uwODOTripL = (UWORD)cp_stHistoryPara.ulODOTrip;
    MC_UpcInfo.stHistoryInfo.uwODOTimeH = (UWORD)(cp_stHistoryPara.ulODOTime >> 16);
    MC_UpcInfo.stHistoryInfo.uwODOTimeL = (UWORD)cp_stHistoryPara.ulODOTime;

    MC_UpcInfo.stHistoryInfo.uwTripSumH = (UWORD)(cp_stHistoryPara.ulTripSum >> 16);
    MC_UpcInfo.stHistoryInfo.uwTripSumL = (UWORD)cp_stHistoryPara.ulTripSum;
    MC_UpcInfo.stHistoryInfo.uwTripSumTimeH = (UWORD)(cp_stHistoryPara.ulTripSumTime >> 16);
    MC_UpcInfo.stHistoryInfo.uwTripSumTimeL = (UWORD)cp_stHistoryPara.ulTripSumTime;

    MC_UpcInfo.stHistoryInfo.uwTorSensorAlamTimes = cp_stHistoryPara.uwTorSensorAlamTimes;
    MC_UpcInfo.stHistoryInfo.uwCadSensorAlamTimes = cp_stHistoryPara.uwCadSensorAlamTimes;
    MC_UpcInfo.stHistoryInfo.uwBikeSpdSensorAlamTimes = cp_stHistoryPara.uwBikeSpdSensorAlamTimes;
    MC_UpcInfo.stHistoryInfo.uwPosSensorAlamTimes = cp_stHistoryPara.uwPosSensorAlamTimes;
    
    MC_UpcInfo.stHistoryInfo.uwRealODOTripH = (UWORD)(cp_stHistoryPara.ulRealODOTrip >> 16);
    MC_UpcInfo.stHistoryInfo.uwRealODOTripL = (UWORD)cp_stHistoryPara.ulRealODOTrip;
    MC_UpcInfo.stHistoryInfo.uwRealODOTimeH = (UWORD)(cp_stHistoryPara.ulRealODOTime >> 16);
    MC_UpcInfo.stHistoryInfo.uwRealODOTimeL = (UWORD)cp_stHistoryPara.ulRealODOTime;

    MC_UpcInfo.stTestParaInfo.uwEEFirstDefaultSetFlg = cp_stFlg.ParaFirstSetFlg;
    MC_UpcInfo.stTestParaInfo.uwSPIOffsetFirstSetFlg = cp_stFlg.SpiOffsetFirstSetFlg;

    MC_UpcInfo.stTestParaInfo.RunModelSelect = cp_stFlg.RunModelSelect;
    MC_UpcInfo.stTestParaInfo.ThetaGetModelSelect = cp_stFlg.ThetaGetModelSelect;
    MC_UpcInfo.stTestParaInfo.CurrentSampleModelSelect = cp_stFlg.CurrentSampleModelSelect;
    MC_UpcInfo.stTestParaInfo.RotateDirectionSelect = cp_stFlg.RotateDirectionSelect;

    MC_UpcInfo.stTestParaInfo.uwInitPosCurAmp = cp_stControlPara.swAlignCurAp;
    MC_UpcInfo.stTestParaInfo.uwVFControlVolAmp = cp_stControlPara.swDragVolAp;
    MC_UpcInfo.stTestParaInfo.uwIFControlCurAmp = cp_stControlPara.swDragCurAp;
    MC_UpcInfo.stTestParaInfo.uwVFIFTargetFreHz = cp_stControlPara.swDragSpdHz;

    MC_UpcInfo.stTestParaInfo.uwSpeedLoopAccRate = 500;
    MC_UpcInfo.stTestParaInfo.uwSpeedLoopDecRate = 100;
    MC_UpcInfo.stTestParaInfo.uwSpeedLoopBandWidthHz = cp_stControlPara.swAsrPIBandwidth;
    MC_UpcInfo.stTestParaInfo.uwSpeedLoopCoefM = cp_stControlPara.swAsrPIM;

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

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

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

    OBC_SetCustomPara.uwWheelPerimeter = (UBYTE)ass_stParaCong.uwWheelPerimeter;
    OBC_SetCustomPara.StartUpMod =  (UBYTE)ass_stParaCong.uwStartMode;
    OBC_SetCustomPara.BikeSpeedLimit =  (UBYTE)ass_stParaSet.uwAssistLimitBikeSpdStart;
    OBC_SetCustomPara.DeltDiameter =  (SBYTE)ass_stParaCong.swDeltPerimeter;
    OBC_SetCustomPara.AssistMod =  (UBYTE)ass_stParaSet.uwAsssistSelectNum;
    OBC_SetCustomPara.AutoPowerOffTime =  (UBYTE)ass_stParaCong.uwAutoPowerOffTime;
    
    if(cp_stMotorPara.swRUdcV == 360)
    {
        slBMSMaxVol = 42000;
        slBMSMinVol = 32000;
    }
    else if(cp_stMotorPara.swRUdcV == 480)
    {
        slBMSMaxVol = 54600;
        slBMSMinVol = 41600;
    }
    else
    {
        slBMSMaxVol = 42000;
        slBMSMinVol = 32000;
    }
}

static UWORD SizeMCUP;
void Can_voInitMC_Run(void)
{
    UBYTE MCU_ID[12];
    ULONG MCU_ID_CRC32;
    flash_voRead();
    // Hardware version
#if(MOTOR_ID_SEL == MOTOR_WELLING_CITY_36V)
	strncpy(MC_VerInfo.HW_Version, (char *)"CITY-36V", 8);
#elif(MOTOR_ID_SEL == MOTOR_WELLING_CITY_48V)
	strncpy(MC_VerInfo.HW_Version, (char *)"CITY-48V", 8);
#elif(MOTOR_ID_SEL == MOTOR_WELLING_MTB_36V)
	strncpy(MC_VerInfo.HW_Version, (char *)"MTB-36V ", 8);
#elif(MOTOR_ID_SEL == MOTOR_WELLING_MTB_48V)
	strncpy(MC_VerInfo.HW_Version, (char *)"MTB-48V ", 8);
#else
	strncpy(MC_VerInfo.HW_Version, (char *)"TEST    ", 8);
#endif
    
    strncpy(MC_VerInfo.HW_Version + 8, (char *)"GD .", 4);
    
    memcpy((uint8_t*)MCU_ID, (uint8_t*)(HW_ID_START_ADDRESS), 12);
    MCU_ID_CRC32 = CRC32_Calculate(MCU_ID,12);
    memcpy((uint8_t*)(MC_VerInfo.HW_Version + 12), (uint8_t*)(&MCU_ID_CRC32), 4);
    
    // Software version
    char chFwVersion[16]="V1r1r0_";
    strncat(chFwVersion,COMMIT_TIME,8);
    strncpy(MC_VerInfo.FW_Version, (char *)chFwVersion, 16);
    
    // Firmware Special Info
    //char chFrimware[32]="TC00000-MC00000-V0r0.  ";
    char chFrimware[32]="TW2024X002-CB0072-V0r0.";//len=23
    strncat(chFrimware,FINGER_PRINT,9);
    strncpy(Firmware_Special, (char *)chFrimware, 32);
    
    // Model name
    memcpy(MC_VerInfo.Mode, flash_stPara.ubMotorVersion, sizeof(flash_stPara.ubMotorVersion));
    // SN
    memcpy(MC_VerInfo.SN_Num, flash_stPara.ubSN, sizeof(flash_stPara.ubSN));
    // ProductLabel
    memcpy(MC_VerInfo.ProductLabel, flash_stPara.ucProductLabel, sizeof(flash_stPara.ucProductLabel));
    // Product information
    //    memcpy(MC_MacInfo.Manufacturer, flash_stPara.ubProdInfo.Manufacturer, sizeof(flash_stPara.ubProdInfo));
    memcpy(&MC_MacInfo, &flash_stPara.ubProdInfo, sizeof(flash_stPara.ubProdInfo));
    // User information
    memcpy(MC_RsASSCII.CustomASCII1, flash_stPara.ubRsASSCII.CustomASCII1, sizeof(MC_RsASSCII.CustomASCII1));
    memcpy(MC_RsASSCII.CustomASCII2, flash_stPara.ubRsASSCII.CustomASCII2, sizeof(MC_RsASSCII.CustomASCII2));
    memcpy(MC_RsASSCII.CustomASCII3, flash_stPara.ubRsASSCII.CustomASCII3, sizeof(MC_RsASSCII.CustomASCII3));

    BMS_VoltEstimat.uwInterResistpu = (UWORD)(((ULONG)1700 << 15) / cof_uwRbOm);     // Q15 0.1mOhm BMS internal resistance 150mOhm + 20mOhm
    mth_voLPFilterCoef(1000000 / 100, EVENT_1MS_HZ, &BMS_swCurIdcLpf.uwKx); // 100Hz
    
    uwRemainDistanceCal = 0xffff;                           // init invalid value
}

void Can_voMC_Run_1ms(void) /* parasoft-suppress METRICS-28 "本项目圈复杂度无法更改，后续避免" */
{
    if (cp_stBikeRunInfoPara.BikeSpeedKmH > 30)
    {
        cp_stBikeRunInfoPara.ulRiTime++;
    }
    if(++ulPowerOnUsedTime>=60000) //1min
    {
        cp_stHistoryPara.ulUsedTime++;
        ulPowerOnUsedTime=0;
    }

    // Error Cnt record and Error Display Set
    MC_ErrorCntRecord.ulAlamCntTimeCnt_1ms++;

    if (MC_ErrorCntRecord.ulAlamCntTimeCnt_1ms == ALAM_DETECT_CNT_IN_1ms && MC_ErrorCode.Code == 0)
    {
        MC_ErrorCntRecord.Protect_OverCurrentCnt = 0;
        MC_ErrorCntRecord.Protect_OverVoltageCnt = 0;
        MC_ErrorCntRecord.Protect_UnderVoltageCnt = 0;
        MC_ErrorCntRecord.Protect_LockRotorCnt = 0;
        MC_ErrorCntRecord.Protect_OverTempCnt = 0;
        MC_ErrorCntRecord.Fault_PhaseLineCnt = 0;

        MC_ErrorCntRecord.ulAlamCntTimeCnt_1ms = 0;
    }


    if (alm_blAlmOccrFlg == TRUE)
    {
        if (alm_blAlmSingleRecordDoneFlg == FALSE)
        {
            if (alm_unCode.bit.IPMFlt == 1)
            {
                MC_ErrorCntRecord.Protect_OverCurrentCnt++;
                cp_stHistoryPara.uwAlamHOcurTimes++;
                if (MC_ErrorCntRecord.Protect_OverCurrentCnt == ALAM_DISPLAY_CNT_0LEVEL) // ALAM_DISPLAY_CNT_2LEVEL
                {
                    MC_ErrorCode.ERROR_Bit.Protect_OverCurrent = 1;
                    /*error log updata*/
                    ErrorLog_Updata();
                    que_ubPushIn(&que_stFlashErrorLog, &que_stErrorLog, 1);
                }
            }

            if (alm_unCode.bit.OvrCur == 1)
            {
                MC_ErrorCntRecord.Protect_OverCurrentCnt++;
                cp_stHistoryPara.uwAlamSOcurTimes++;
                if (MC_ErrorCntRecord.Protect_OverCurrentCnt == ALAM_DISPLAY_CNT_0LEVEL) // ALAM_DISPLAY_CNT_2LEVEL
                {
                    MC_ErrorCode.ERROR_Bit.Protect_OverCurrent = 1;
                    /*error log updata*/
                    ErrorLog_Updata();
                    que_ubPushIn(&que_stFlashErrorLog, &que_stErrorLog, 1);
                }
            }

            if (alm_unCode.bit.OvrVlt == 1)
            {
                MC_ErrorCntRecord.Protect_OverVoltageCnt++;
                cp_stHistoryPara.uwAlamOVolTimes++;
                if (MC_ErrorCntRecord.Protect_OverVoltageCnt == ALAM_DISPLAY_CNT_0LEVEL) // ALAM_DISPLAY_CNT_2LEVEL
                {
                    MC_ErrorCode.ERROR_Bit.Protect_OverVoltage = 1;
                    /*error log updata*/
                    ErrorLog_Updata();
                    que_ubPushIn(&que_stFlashErrorLog, &que_stErrorLog, 1);
                }
            }

            if (alm_unCode.bit.UndrVlt == 1)
            {
                MC_ErrorCntRecord.Protect_UnderVoltageCnt++;
                cp_stHistoryPara.uwAlamUVolTimes++;
                if (MC_ErrorCntRecord.Protect_UnderVoltageCnt == ALAM_DISPLAY_CNT_0LEVEL) // ALAM_DISPLAY_CNT_2LEVEL
                {
                    MC_ErrorCode.ERROR_Bit.Protect_UnderVoltage = 1;
                    /*error log updata*/
                    ErrorLog_Updata();
                    que_ubPushIn(&que_stFlashErrorLog, &que_stErrorLog, 1);
                }
            }

            if (alm_unCode.bit.RotorLock == 1)
            {
                MC_ErrorCntRecord.Protect_LockRotorCnt++;
                cp_stHistoryPara.uwAlamRotorLockTimes++;
                if (MC_ErrorCntRecord.Protect_LockRotorCnt == ALAM_DISPLAY_CNT_0LEVEL) // ALAM_DISPLAY_CNT_2LEVEL
                {
                    MC_ErrorCode.ERROR_Bit.Protect_LockRotor = 1;
                    /*error log updata*/
                    ErrorLog_Updata();
                    que_ubPushIn(&que_stFlashErrorLog, &que_stErrorLog, 1);
                }
            }

            if (alm_unCode.bit.IPMOvrHeat == 1)
            {
                MC_ErrorCntRecord.Protect_OverTempCnt++;
                cp_stHistoryPara.uwAlamOHeatTimes++;
                if (MC_ErrorCntRecord.Protect_OverTempCnt == ALAM_DISPLAY_CNT_0LEVEL)
                {
                    MC_ErrorCode.ERROR_Bit.Protect_OverTemp = 1;
                    /*error log updata*/
                    ErrorLog_Updata();
                    que_ubPushIn(&que_stFlashErrorLog, &que_stErrorLog, 1);
                }
            }

            if (alm_unCode.bit.PhsLoss == 1)
            {
                MC_ErrorCntRecord.Fault_PhaseLineCnt++;
                cp_stHistoryPara.uwAlamPhsLossTimes++;
                if (MC_ErrorCntRecord.Fault_PhaseLineCnt == ALAM_DISPLAY_CNT_0LEVEL)
                {
                    MC_ErrorCode.ERROR_Bit.Fault_PhaseLine = 1;
                    /*error log updata*/
                    ErrorLog_Updata();
                    que_ubPushIn(&que_stFlashErrorLog, &que_stErrorLog, 1);
                }
            }

            // if(alm_unCode.bit.CommOvrTm)
            // {
            //     cp_stHistoryPara.uwAlamComOTimeTimes++;
            // }
            
            if (alm_unCode.bit.SpiThetaFlt == 1)
            {
                MC_ErrorCode.ERROR_Bit.Fault_SpiPosSensor = 1;
                /*error log updata*/
                ErrorLog_Updata();
                que_ubPushIn(&que_stFlashErrorLog, &que_stErrorLog, 1);
            }
            
            if (alm_unBikeCode.bit.BikeSpdSen == 1)
            {
                MC_ErrorCode.ERROR_Bit.Fault_BikeSpdSensor = 1;
                /*error log updata*/
                ErrorLog_Updata();
                que_ubPushIn(&que_stFlashErrorLog, &que_stErrorLog, 1);
            }
            
            if (alm_unBikeCode.bit.CadenceSen == 1)
            {
                cp_stHistoryPara.uwCadSensorAlamTimes++;
                MC_ErrorCode.ERROR_Bit.Fault_CadenceSensor = 1;
                /*error log updata*/
                ErrorLog_Updata();
                que_ubPushIn(&que_stFlashErrorLog, &que_stErrorLog, 1);
            }
            
            if (alm_unBikeCode.bit.PCBNTC == 1)
            {
                MC_ErrorCode.ERROR_Bit.Fault_PCBNTC = 1;
                /*error log updata*/
                ErrorLog_Updata();
                que_ubPushIn(&que_stFlashErrorLog, &que_stErrorLog, 1);
            }
            
            if (alm_unBikeCode.bit.Throttle == 1)
            {
                MC_ErrorCode.ERROR_Bit.Fault_GasSensor = 1;
                /*error log updata*/
                ErrorLog_Updata();
                que_ubPushIn(&que_stFlashErrorLog, &que_stErrorLog, 1);
            }
            
            if (alm_unBikeCode.bit.TorqSen == 1)
            {
                MC_ErrorCode.ERROR_Bit.Fault_TorqueSensor = 1;
                /*error log updata*/
                ErrorLog_Updata();
                que_ubPushIn(&que_stFlashErrorLog, &que_stErrorLog, 1);
                
            }
            
            alm_blAlmSingleRecordDoneFlg = TRUE;
        }
    }


    // Claear error Display
    if (MC_ErrorCode.ERROR_Bit.Protect_OverCurrent == 1)
    {
        if (alm_unCode.bit.IPMFlt != 1 && alm_unCode.bit.OvrCur != 1)
        {
            MC_ErrorCntRecord.Protect_OverCurrentCnt = 0;
            MC_ErrorCode.ERROR_Bit.Protect_OverCurrent = 0;
        }
    }


    if (MC_ErrorCode.ERROR_Bit.Protect_OverVoltage == 1)
    {
        if (alm_unCode.bit.OvrVlt != 1)
        {
            MC_ErrorCntRecord.Protect_OverVoltageCnt = 0;
            MC_ErrorCode.ERROR_Bit.Protect_OverVoltage = 0;
        }
    }


    if (MC_ErrorCode.ERROR_Bit.Protect_UnderVoltage == 1)
    {
        if (alm_unCode.bit.UndrVlt != 1)
        {
            MC_ErrorCntRecord.Protect_UnderVoltageCnt = 0;
            MC_ErrorCode.ERROR_Bit.Protect_UnderVoltage = 0;
        }
    }


    if (MC_ErrorCode.ERROR_Bit.Protect_LockRotor == 1)
    {
        if (alm_unCode.bit.RotorLock != 1)
        {
            MC_ErrorCntRecord.Protect_LockRotorCnt = 0;
            MC_ErrorCode.ERROR_Bit.Protect_LockRotor = 0;
        }
    }


    if (MC_ErrorCode.ERROR_Bit.Protect_OverTemp == 1)
    {
        if (alm_unCode.bit.IPMOvrHeat != 1)
        {
            MC_ErrorCntRecord.Protect_OverTempCnt = 0;
            MC_ErrorCode.ERROR_Bit.Protect_OverTemp = 0;
        }
    }


    if (MC_ErrorCode.ERROR_Bit.Fault_PhaseLine == 1)
    {
        if (alm_unCode.bit.PhsLoss != 1)
        {
            MC_ErrorCntRecord.Fault_PhaseLineCnt = 0;
            MC_ErrorCode.ERROR_Bit.Fault_PhaseLine = 0;
        }
    }

    
    if (MC_ErrorCode.ERROR_Bit.Fault_SpiPosSensor == 1)
    {
        if (alm_unCode.bit.SpiThetaFlt != 1)
        {
            MC_ErrorCode.ERROR_Bit.Fault_SpiPosSensor = 0;
        }
    }

    if (MC_ErrorCode.ERROR_Bit.Fault_BikeSpdSensor == 1)
    {
        if (alm_unBikeCode.bit.BikeSpdSen != 1)
        {
            MC_ErrorCode.ERROR_Bit.Fault_BikeSpdSensor = 0;
        }
    }
 
    if (MC_ErrorCode.ERROR_Bit.Fault_CadenceSensor == 1)
    {
        if (alm_unBikeCode.bit.CadenceSen != 1)
        {
            MC_ErrorCode.ERROR_Bit.Fault_CadenceSensor = 0;
        }
    }
    
    if (MC_ErrorCode.ERROR_Bit.Fault_PCBNTC == 1)
    {
        if (alm_unBikeCode.bit.PCBNTC != 1)
        {
            MC_ErrorCode.ERROR_Bit.Fault_PCBNTC = 0;
        }
    }

    if (MC_ErrorCode.ERROR_Bit.Fault_GasSensor == 1)
    {
        if (alm_unBikeCode.bit.Throttle != 1)
        {
            MC_ErrorCode.ERROR_Bit.Fault_GasSensor = 0;
        }
    }
    
    if (MC_ErrorCode.ERROR_Bit.Fault_TorqueSensor == 1)
    {
        if (alm_unBikeCode.bit.TorqSen != 1)
        {
            MC_ErrorCode.ERROR_Bit.Fault_TorqueSensor = 0;
        }
    }
    
    SWORD TempPower;
    if (FSM2nd_Run_state.state == Exit)
    {
        TempPower = 0;
    }
    else
    {
        TempPower = scm_stMotoPwrInLpf.slY.sw.hi;
    }
    
    BMS_VoltEstimat.swIdcPu = (SWORD)(((SLONG)TempPower << 13) / (SLONG)adc_stUpOut.uwVdcLpfPu); // Q15+Q13-Q14=Q14  Calculated dc current
    if (BMS_VoltEstimat.swIdcPu < 0)
    {
      BMS_VoltEstimat.swIdcPu = 0;
    }
    mth_voLPFilter(BMS_VoltEstimat.swIdcPu, &BMS_swCurIdcLpf); 
    BMS_VoltEstimat.uwVdcCompPu = (UWORD)((ULONG)BMS_swCurIdcLpf.slY.sw.hi * BMS_VoltEstimat.uwInterResistpu >> 15); // Q14+Q15-Q15=Q14
}

void Can_voMC_Run_5ms(void)
{
    cp_stBikeRunInfoPara.BikeSpeedKmH =
    		(UWORD)((((UQWORD)bikespeed_stFreGetOut.uwLPFFrequencyPu * FBASE * (ass_stParaCong.uwWheelPerimeter + ass_stParaCong.swDeltPerimeter) * 36 >> 20) *
         1048 * 10) >>  20); //    1048 = Q20(1/1000)    0.1 km/h
#ifdef TEST
    do
    {
        ULONG ulBikeSpeedCalTrip = 0;
        static ULONG ulBikeSpeedCalTripCount = 0;
        cp_stBikeRunInfoPara.BikeSpeedKmH = (((ULONG)cadence_stFreGetOut.uwLPFFrequencyPu * cof_uwFbHz * 60) >> 20) \
                                            * ass_stParaCong.uwNmFrontChainring/ass_stParaCong.uwNmBackChainring*(ass_stParaCong.uwWheelPerimeter + ass_stParaCong.swDeltPerimeter)*6/1000;
        ulBikeSpeedCalTripCount++;
        ulBikeSpeedCalTrip = cp_stBikeRunInfoPara.BikeSpeedKmH * 5 * ulBikeSpeedCalTripCount / 36000;
        if(ulBikeSpeedCalTrip > 100)
        {
          ulBikeSpeedCalTripCount = 0;
          bikespeed_stFreGetOut.blUpdateTripCntFlg = TRUE;
        }
    }while(0);
#endif
}

void Can_voMC_Run_200ms(void)
{
    SWORD TempPower;
    
    if((cp_ulSystickCnt - ulBMS_ComTimeOutCount) > 3000)
    {
        blBMSCommFault = TRUE;       // communication abnormal
    }
    else
    {
        blBMSCommFault = FALSE;       // communication normal
    }
    
    Can_GearSt_switch();
    SizeMCUP = sizeof(MC_UpcInfo.stAssistInfo);
    if (MC_BC_COM == 1)
    {
        MC_RunInfoToCDL.SysStatus = FSM1st_Sys_state.state;
        MC_RunInfoToCDL.SubStatus = FSM2nd_Run_state.state;
        MC_RunInfoToCDL.MotorStatus = curSpeed_state.state;
        MC_RunInfoToCDL.AssitStatus = Ass_FSM;
        MC_RunInfoToCDL.Id = scm_swIdRefPu;
        MC_RunInfoToCDL.Iq = scm_swIqRefPu;
        MC_RunInfoToCDL.Ud = scm_swUdRefPu;
        MC_RunInfoToCDL.Uq = scm_swUqRefPu;
        MC_RunInfoToCDL.InstantTorq = torsensor_stTorSensorOut.uwTorqueReg;
        MC_RunInfoToCDL.FilteTorq = torsensor_stTorSensorOut.uwTorqueLPFPu;
        MC_RunInfoToCDL.FreqTorq = ass_stTorqMafValue.slAverValue;
        MC_RunInfoToCDL.RS[0] = scm_swIdFdbLpfPu;
        MC_RunInfoToCDL.RS[1] = scm_swIqFdbLpfPu;
        MC_RunInfoToCDL.RS[2] = ass_stCalOut.swTorAss2CurrentTemp;
        MC_RunInfoToCDL.RS[3] = bikethrottle_stBikeThrottleOut.uwThrottlePercent;
        SendData(ID_MC_TO_CDL, MODE_REPORT, 0xBA20, (UBYTE *)&MC_RunInfoToCDL.SysStatus);
    }

    MC_RunInfo.BikeSpeed = cp_stBikeRunInfoPara.BikeSpeedKmH;                //0.1km/h
    MC_RunInfo.MotorSpeed = (SWORD)((SLONG)scm_uwSpdFbkLpfAbsPu * (SLONG)cof_uwVbRpm >> 15); //1rpm
    TempPower = scm_swMotorPwrInLpfWt;
    if (TempPower > 5000)
    {
        TempPower = 5000;
    }
    if (TempPower < 0)
    {
        TempPower = 0;
    }
    if (sysctrl_stPwmState.blPwmOnflg == FALSE)
    {
        TempPower = 0;
    }
    else
    {
    }
    do
    {
      SWORD PowerTemp1 = 0;
      static SLONG PowerFlt = 0;
      PowerTemp1 = ((TempPower / 10) * 5 ) >> 3; 
      PowerTemp1 = (PowerTemp1 < 25) ? 0 : PowerTemp1;
      PowerFlt += ((PowerTemp1 << 10) - PowerFlt) >> 3;
      MC_RunInfo.Power = (PowerFlt < 0) ? 0 : (PowerFlt) >> 10;
    }while(0);
    
    //MC_RunInfo.Power = TempPower / 10;                                                                    //>电功率 1W
    //MC_RunInfo.Power = (scm_swIqFdbLpfPu * 250 * cof_uwIbAp / 1500) >> 14;                                      //MaxIq = 15A,MaxPower=250W
    MC_RunInfo.BusVoltage = (UWORD)((((ULONG)adc_stUpOut.uwVdcLpfPu + (ULONG)BMS_VoltEstimat.uwVdcCompPu) * cof_uwUbVt * 100) >> 14); //母线电压 1mV
    //MC_RunInfo.BusCurrent = (UWORD)((ULONG)BMS_VoltEstimat.swIdcPu * cof_uwIbAp * 100 >> 14);                                  //母线电流 1mA
    BMS_VoltEstimat.uwIbusLpf = (BMS_swCurIdcLpf.slY.sw.hi * cof_uwIbAp * 15) >> 14;//mA
    MC_RunInfo.BusCurrent = (ABS(scm_swIqFdbLpfPu) * cof_uwIbAp * 10) >> 14;
    MC_RunInfo.Cadence = (UBYTE)(((ULONG)cadence_stFreGetOut.uwLPFFrequencyPu * cof_uwFbHz * 60) >> 20);                              //踏频 1rpm
    MC_RunInfo.Torque = (UBYTE)(((ULONG)torsensor_stTorSensorOut.uwTorqueLPFPu * cof_uwTorqNm / 10) >> 14);                    //踩踏力矩 1Nm
    MC_RunInfo.CadenceDir = (MC_CadenceDir_Struct_t)cadence_stFreGetOut.cadence_dir;                                  //踩踏方向 0-正,1-反,2-停止
    MC_RunInfo.GearSt = (UBYTE)MC_ControlCode.GearSt;                                                                        //助力档位
    MC_RunInfo.LightSwitch = MC_ControlCode.LightSwitch;                                                              //灯开关 0xF0-关，0xF1-开
    MC_RunInfo.SOC = (UBYTE)Can_SOC_Cal();                                                                                   //剩余电量 1%
    Can_Trip_Cal();
    MC_RunInfo.TorqueReg = iAdc_GetResultPointer(0)[HW_ADC_TORQ_CH];;                                                                       //力矩AD值

    if (cp_stBikeRunInfoPara.blGearStUpdate)
    {
        if((cp_stBikeRunInfoPara.uwBikeGear > 0) && (cp_stBikeRunInfoPara.uwBikeGear <= 5))
        {
            MC_RunInfo.PowerPerKm =
                    (UBYTE)(*(&cp_stHistoryPara.uwG1AvgPwrConsumption + (cp_stBikeRunInfoPara.uwBikeGear - 1)) / 10); //平均功耗 0.01Ah/km  /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
            uwRemainDistanceCal = BMS_RunInfo.RC / MC_RunInfo.PowerPerKm / 10;
        }
        else
        {
            MC_RunInfo.PowerPerKm = 0;         
            uwRemainDistanceCal = 0xffff;                           //invalid value
        }

        cp_stBikeRunInfoPara.BMSRestChargeLast = BMS_RunInfo.RC;
        cp_stBikeRunInfoPara.uwPowerPerKm = 0;
        cp_stBikeRunInfoPara.uwAvePowerPerKm = 0;
        cp_stBikeRunInfoPara.uwPowerPerKmSum = 0;
        memset(cp_stBikeRunInfoPara.uwPowerPerKmBuf, 0, sizeof(cp_stBikeRunInfoPara.uwPowerPerKmBuf));
        cp_stBikeRunInfoPara.uwAvePowerCNT = 0;
        cp_stBikeRunInfoPara.uwCruisDis = 0;
    }
    
    if(blBMSCommFault == TRUE)
    {
        MC_RunInfo.RemainDistance = 0xeeee;             /* no bms info*/
    }
    else
    {
        MC_RunInfo.RemainDistance = uwRemainDistanceCal;
    }
    
    MC_RunInfo.T_PCB = (UBYTE)adc_stUpOut.PCBTemp + (UBYTE)40;                    //>PCB温度 +40℃
    MC_RunInfo.T_Coil = (UBYTE)adc_stUpOut.PCBTemp + (UBYTE)40;                   //绕组温度 +40℃
    MC_RunInfo.T_MCU = (UBYTE)adc_stUpOut.PCBTemp + (UBYTE)40;                    //MCU温度 +40℃，
    MC_RunInfo.Ride_Time = (UWORD)(cp_stBikeRunInfoPara.ulRiTime >> 10);     //开机后骑行时间 1s

    if (MC_WorkMode == 1)
    {
        SendData(ID_MC_BC, MODE_REPORT, 0x1020, (UBYTE *)&MC_RunInfo.BikeSpeed);
    }
}

void Can_Trip_Cal(void)
{
    if (bikespeed_stFreGetOut.blUpdateTripCntFlg == TRUE)
    {
        MC_RunInfo.Ride_Km++;
        cp_stHistoryPara.ulODOTrip++; // Unit: 0.1km
        cp_stHistoryPara.ulRealODOTrip++; // Unit: 0.1km
        cp_stHistoryPara.ulTripSum++;
        Can_RemainTrip_Cal();
        bikespeed_stFreGetOut.blUpdateTripCntFlg = FALSE;
    }

    MC_RideLog.ODO_Km = cp_stHistoryPara.ulODOTrip;
    MC_RideLog.TRIP_Km = cp_stHistoryPara.ulTripSum;

    MC_RideLog.ODO_Time = cp_stHistoryPara.ulODOTime + (cp_stBikeRunInfoPara.ulRiTime >> 10) / 60;      // min
    MC_RideLog.TRIP_Time = cp_stHistoryPara.ulTripSumTime + (cp_stBikeRunInfoPara.ulRiTime >> 10) / 60; // min
    cp_stHistoryPara.ulRealODOTime = cp_stHistoryPara.ulRealODOTime + (cp_stBikeRunInfoPara.ulRiTime >> 10) / 60;
    
    /*TRIP里程超9999.9km时，清除TRIP里程和时间*/
    if(MC_RideLog.TRIP_Km > 99999)
    {
       cp_stHistoryPara.ulTripSum = 0;
       cp_stHistoryPara.ulTripSumTime = 0;
       MC_RunInfo.Ride_Km = 0;
       MC_RunInfo.Ride_Time = 0;
       MC_RideLog.TRIP_Km = 0;
       MC_RideLog.TRIP_Time = 0;
       cp_stHistoryPara.ulODOTime = cp_stHistoryPara.ulODOTime + (cp_stBikeRunInfoPara.ulRiTime >> 10) / 60;
       cp_stBikeRunInfoPara.ulRiTime = 0;
    }
}

void Can_RemainTrip_Cal(void)
{
    if(blBMSCommFault == FALSE)
    {
        UWORD uwCruisCoef;                         //单位功耗
        cp_stBikeRunInfoPara.uwCruisDis++;        // 0.1 km
        if (cp_stBikeRunInfoPara.uwCruisDis >= 5) // 5 = 0.5km
        {
            cp_stBikeRunInfoPara.uwCruisDis = 0;
            cp_stBikeRunInfoPara.BMSRestChargeNow = BMS_RunInfo.RC;
            cp_stBikeRunInfoPara.uwPowerPerKm = (cp_stBikeRunInfoPara.BMSRestChargeLast - cp_stBikeRunInfoPara.BMSRestChargeNow)
                                                << 1; // BMS_RunInfo.RC   (BMSRestChargeLast - BMSRestChargeNow) /0.5 km
            cp_stBikeRunInfoPara.BMSRestChargeLast = cp_stBikeRunInfoPara.BMSRestChargeNow;
            cp_stBikeRunInfoPara.uwPowerPerKmSum -= cp_stBikeRunInfoPara.uwPowerPerKmBuf[cp_stBikeRunInfoPara.uwAvePowerCNT];
            cp_stBikeRunInfoPara.uwPowerPerKmBuf[cp_stBikeRunInfoPara.uwAvePowerCNT] = cp_stBikeRunInfoPara.uwPowerPerKm;
            cp_stBikeRunInfoPara.uwPowerPerKmSum += cp_stBikeRunInfoPara.uwPowerPerKmBuf[cp_stBikeRunInfoPara.uwAvePowerCNT];
            if (cp_stBikeRunInfoPara.uwPowerPerKmBuf[31] == 0)
            {
                cp_stBikeRunInfoPara.uwAvePowerPerKm = cp_stBikeRunInfoPara.uwPowerPerKmSum / (cp_stBikeRunInfoPara.uwAvePowerCNT + 1);
            }
            else
            {
                cp_stBikeRunInfoPara.uwAvePowerPerKm = cp_stBikeRunInfoPara.uwPowerPerKmSum >> 5;
            }
            cp_stBikeRunInfoPara.uwAvePowerCNT++;
            if (cp_stBikeRunInfoPara.uwAvePowerCNT >= 32)
            {
                cp_stBikeRunInfoPara.uwAvePowerCNT = 0;
            }
            
            /*限制功耗防止续航里程过大或过小*/
            if(cp_stBikeRunInfoPara.uwAvePowerPerKm < 50)
            {
                cp_stBikeRunInfoPara.uwAvePowerPerKm = 50;        /*limit min*/
            }
            else if(cp_stBikeRunInfoPara.uwAvePowerPerKm > 500)
            {
                cp_stBikeRunInfoPara.uwAvePowerPerKm = 500;     /*limit max*/
            }
            else
            {
                /* no deal with */
            }

            if(cp_stBikeRunInfoPara.uwAvePowerPerKm > 0)
            {
                if (cp_stBikeRunInfoPara.uwBikeGear == 1)
                {
                    uwCruisCoef = (UWORD)(((ULONG)cp_stBikeRunInfoPara.uwAvePowerPerKm << 12) / cp_stHistoryPara.uwG1AvgPwrConsumption);
                    cp_stHistoryPara.uwG1AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG1AvgPwrConsumption * uwCruisCoef >> 12);
                    cp_stHistoryPara.uwG2AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG2AvgPwrConsumption * uwCruisCoef >> 12);
                    cp_stHistoryPara.uwG3AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG3AvgPwrConsumption * uwCruisCoef >> 12);
                    cp_stHistoryPara.uwG4AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG4AvgPwrConsumption * uwCruisCoef >> 12);
                    cp_stHistoryPara.uwG5AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG5AvgPwrConsumption * uwCruisCoef >> 12);
                    MC_RunInfo.PowerPerKm = (UBYTE)(cp_stHistoryPara.uwG1AvgPwrConsumption / 10);
                }
                else if (cp_stBikeRunInfoPara.uwBikeGear == 2)
                {
                    uwCruisCoef = (UWORD)(((ULONG)cp_stBikeRunInfoPara.uwAvePowerPerKm << 12) / cp_stHistoryPara.uwG2AvgPwrConsumption);
                    cp_stHistoryPara.uwG1AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG1AvgPwrConsumption * uwCruisCoef >> 12);
                    cp_stHistoryPara.uwG2AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG2AvgPwrConsumption * uwCruisCoef >> 12);
                    cp_stHistoryPara.uwG3AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG3AvgPwrConsumption * uwCruisCoef >> 12);
                    cp_stHistoryPara.uwG4AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG4AvgPwrConsumption * uwCruisCoef >> 12);
                    cp_stHistoryPara.uwG5AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG5AvgPwrConsumption * uwCruisCoef >> 12);
                    MC_RunInfo.PowerPerKm = (UBYTE)(cp_stHistoryPara.uwG2AvgPwrConsumption / 10);
                }
                else if (cp_stBikeRunInfoPara.uwBikeGear == 3)
                {
                    uwCruisCoef = (UWORD)(((ULONG)cp_stBikeRunInfoPara.uwAvePowerPerKm << 12) / cp_stHistoryPara.uwG3AvgPwrConsumption);
                    cp_stHistoryPara.uwG1AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG1AvgPwrConsumption * uwCruisCoef >> 12);
                    cp_stHistoryPara.uwG2AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG2AvgPwrConsumption * uwCruisCoef >> 12);
                    cp_stHistoryPara.uwG3AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG3AvgPwrConsumption * uwCruisCoef >> 12);
                    cp_stHistoryPara.uwG4AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG4AvgPwrConsumption * uwCruisCoef >> 12);
                    cp_stHistoryPara.uwG5AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG5AvgPwrConsumption * uwCruisCoef >> 12);
                    MC_RunInfo.PowerPerKm = (UBYTE)(cp_stHistoryPara.uwG3AvgPwrConsumption / 10);
                }
                else if (cp_stBikeRunInfoPara.uwBikeGear == 4)
                {
                    uwCruisCoef = (UWORD)(((ULONG)cp_stBikeRunInfoPara.uwAvePowerPerKm << 12) / cp_stHistoryPara.uwG4AvgPwrConsumption);
                    cp_stHistoryPara.uwG1AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG1AvgPwrConsumption * uwCruisCoef >> 12);
                    cp_stHistoryPara.uwG2AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG2AvgPwrConsumption * uwCruisCoef >> 12);
                    cp_stHistoryPara.uwG3AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG3AvgPwrConsumption * uwCruisCoef >> 12);
                    cp_stHistoryPara.uwG4AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG4AvgPwrConsumption * uwCruisCoef >> 12);
                    cp_stHistoryPara.uwG5AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG5AvgPwrConsumption * uwCruisCoef >> 12);
                    MC_RunInfo.PowerPerKm = (UBYTE)(cp_stHistoryPara.uwG4AvgPwrConsumption / 10);
                }
                else if (cp_stBikeRunInfoPara.uwBikeGear == 5)
                {
                    uwCruisCoef = (UWORD)(((ULONG)cp_stBikeRunInfoPara.uwAvePowerPerKm << 12) / cp_stHistoryPara.uwG5AvgPwrConsumption);
                    cp_stHistoryPara.uwG1AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG1AvgPwrConsumption * uwCruisCoef >> 12);
                    cp_stHistoryPara.uwG2AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG2AvgPwrConsumption * uwCruisCoef >> 12);
                    cp_stHistoryPara.uwG3AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG3AvgPwrConsumption * uwCruisCoef >> 12);
                    cp_stHistoryPara.uwG4AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG4AvgPwrConsumption * uwCruisCoef >> 12);
                    cp_stHistoryPara.uwG5AvgPwrConsumption = (UWORD)((ULONG)cp_stHistoryPara.uwG5AvgPwrConsumption * uwCruisCoef >> 12);
                    MC_RunInfo.PowerPerKm = (UBYTE)(cp_stHistoryPara.uwG5AvgPwrConsumption / 10);
                }
                else
                {
                    uwCruisCoef = 4096;
                }
                
                uwRemainDistanceCal = BMS_RunInfo.RC / MC_RunInfo.PowerPerKm / 10;
            }
        }
    }
}

//#if ((MOTOR_ID_SEL == MOTOR_WELLING_CITY_36V) || (MOTOR_ID_SEL == MOTOR_WELLING_MTB_36V))
//static SLONG slBMSMaxVol = 42000;
//static SLONG slBMSMinVol = 32000;
//#elif ((MOTOR_ID_SEL == MOTOR_WELLING_CITY_48V) || (MOTOR_ID_SEL == MOTOR_WELLING_MTB_48V))
//static SLONG slBMSMaxVol = 54600;
//static SLONG slBMSMinVol = 41600;
//#endif
static SWORD SOC_Cnt, SOC_Value, SOC_MIN;
static ULONG Voltage_Sum;
static BOOL  blSOCfirstSet = FALSE;

UWORD Can_SOC_Cal(void)
{
    UWORD templenght, VoltageAvg = 0;

    if (cp_ulSystickCnt < 1000)
    {
        return (UWORD)0;
    }
    
    if(blBMSCommFault == FALSE)
    {
        SOC_Value = BMS_RunInfo.SOC;                      
    }
    else if (blSOCfirstSet == FALSE)
    {  
        if(0 == ulBMS_ComTimeOutCount)
        {
            if (MC_RunInfo.BusVoltage >= slBMSMaxVol)
            {
                SOC_Value = 100;
            }
            else if (MC_RunInfo.BusVoltage <= slBMSMinVol)
            {
                SOC_Value = 0;
            }
            else
            {
                SOC_Value = (SWORD)(((SLONG)MC_RunInfo.BusVoltage - slBMSMinVol) * 100 / (slBMSMaxVol - slBMSMinVol));
            }
            SOC_MIN = SOC_Value;
        }
        else
        {
            SOC_MIN = BMS_RunInfo.SOC;
        }
        blSOCfirstSet = TRUE;
    }
    else
    {
        templenght = 300; // 60s in 200ms time task
        SOC_Cnt++;
        Voltage_Sum += MC_RunInfo.BusVoltage;
        if (SOC_Cnt >= templenght) // 60s
        {
            VoltageAvg = (UWORD)(Voltage_Sum / templenght);
            if (VoltageAvg <= slBMSMinVol)
            {
                SOC_Value = 0;
            }
            else
            {
                SOC_Value = (SWORD)(((SLONG)VoltageAvg - (SLONG)slBMSMinVol) * 100 / ((SLONG)slBMSMaxVol - (SLONG)slBMSMinVol));
            }
            
            if (SOC_Value < SOC_MIN)
            {
                SOC_MIN = SOC_Value;
            }
            else
            {
            }
            SOC_Cnt = 0;
            Voltage_Sum = 0;
        }
        
        if (SOC_Value > SOC_MIN)
        {
            SOC_Value = SOC_MIN;
        }
        else if (SOC_Value < 0)
        {
            SOC_Value = 0;
        }
        else
        {
            // do nothing
        }
    }
    
    return (UWORD)SOC_Value;
}

void Can_GearSt_switch(void)
{
    cp_stBikeRunInfoPara.uwBikeGearLast = cp_stBikeRunInfoPara.uwBikeGear;

    if (MC_WorkMode == 1) 
    {
        ulOBC_ComTimeOutCount = cp_ulSystickCnt;
    }
#ifdef RUN_ARCH_SIM 
    ulOBC_ComTimeOutCount = cp_ulSystickCnt;
#endif
    if ((cp_ulSystickCnt - ulOBC_ComTimeOutCount) < 3000) 
    {
        if (MC_ControlCode.GearSt <= 0x05)
        {
            cp_stBikeRunInfoPara.uwBikeGear = (UWORD)MC_ControlCode.GearSt;
        }
        else if (MC_ControlCode.GearSt == 0x33)
        {
            cp_stBikeRunInfoPara.uwBikeGear = 5;
        }
        else if (MC_ControlCode.GearSt == 0x22)
        {
            cp_stBikeRunInfoPara.uwBikeGear = 0x22;
        }
        else
        {
            // do nothing
        }
    }
    else 
    {
        MC_ControlCode.GearSt = MC_GearSt_OFF;
        MC_RunInfo.GearSt = 0x00;
        cp_stBikeRunInfoPara.uwBikeGear = 0x00;
    }

    if (cp_stBikeRunInfoPara.uwBikeGear != cp_stBikeRunInfoPara.uwBikeGearLast)
    {
        cp_stBikeRunInfoPara.blGearStUpdate = TRUE;
    }
    else
    {
        cp_stBikeRunInfoPara.blGearStUpdate = FALSE;
    }
}

void Can_Light_switch(void)
{
    /* light switch*/
    if (MC_ControlCode.LightSwitch == 0xF1)
    {
        cp_stBikeRunInfoPara.uwLightSwitch = 1;
    }
    else if (MC_ControlCode.LightSwitch == 0xF0)
    {
        cp_stBikeRunInfoPara.uwLightSwitch = 0;
    }
    else
    {
        // do nothing
    }
}

void Can_AssistCoef_Read(const UPC_CurveOrderInfo_Struct_t *order)
{
    MC_UpcInfo.stAssistInfo.stCurveOrderInfo = *order;
    
    memcpy(&MC_UpcInfo.stAssistInfo.slTorquePolyA, &flash_stPara.slTorqAssGain[order->uwTorqueCurveNum - 1], sizeof(POLY_COEF));
    memcpy(&MC_UpcInfo.stAssistInfo.slCadencePolyA, &flash_stPara.slCadAssGain[order->uwCadenceCurveNum - 1], sizeof(POLY_COEF));
}

void Can_AssistCoef_Write(const UPC_CurveOrderInfo_Struct_t *order)
{
    memcpy(&flash_stPara.slTorqAssGain[order->uwTorqueCurveNum - 1], &MC_UpcInfo.stAssistInfo.slTorquePolyA, sizeof(POLY_COEF));
    memcpy(&flash_stPara.slCadAssGain[order->uwCadenceCurveNum - 1], &MC_UpcInfo.stAssistInfo.slCadencePolyA, sizeof(POLY_COEF));
}

void ErrorLog_Updata(void)
{
    que_stErrorLog.ErrorCode = MC_ErrorCode.Code;
    que_stErrorLog.RunTime = cp_stHistoryPara.ulUsedTime;//MC_RunInfo.Ride_Time;
    que_stErrorLog.RunInfo = MC_RunInfo;
    //memcpy((uint8_t*)&que_stErrorLog.RunInfo, (uint8_t*)&MC_RunInfo.BikeSpeed, sizeof(MC_RunInfo_Struct_t));
    que_stErrorLog.IqCurrentPu = scm_swIqFdbLpfPu;
    que_stErrorLog.IqVoltagePu = scm_swUqRefPu;
    que_stErrorLog.IdCurrentPu = scm_swIdFdbLpfPu;
    que_stErrorLog.IdVoltagePu = scm_swUdRefPu;
}