feat：增加力矩传感器单元测试并通过，删除该模块与alarm重复的故障功能

User project/1.FrameLayer/Source/main.c

@@ -343,139 +343,136 @@ void mn_voParaSet(void)
 ****************************************************************/
 void mn_voParaUpdate(void)
 {
-    if (cp_stFlg.ParaUpdateFlg == TRUE)
+    if (cp_stFlg.ParaMInfoUpdateFlg == TRUE)
     {
-        if (cp_stFlg.ParaMInfoUpdateFlg == TRUE)
-        {
-            cp_stMotorPara.swMotrPolePairs = (SWORD)MC_UpcInfo.stMotorInfo.uwPolePairs;
-            cp_stMotorPara.swRsOhm = (SWORD)MC_UpcInfo.stMotorInfo.uwRsmOhm;
-            cp_stMotorPara.swLdmH = (SWORD)MC_UpcInfo.stMotorInfo.uwLduH;
-            cp_stMotorPara.swLqmH = (SWORD)MC_UpcInfo.stMotorInfo.uwLquH;
-            cp_stMotorPara.swFluxWb = (SWORD)MC_UpcInfo.stMotorInfo.uwFluxmWb;
-            cp_stMotorPara.swIdMaxA = (SWORD)MC_UpcInfo.stMotorInfo.uwIdMaxA;
-            cp_stMotorPara.swIdMinA = (SWORD)MC_UpcInfo.stMotorInfo.uwIdMinA;
-            cp_stMotorPara.swRSpeedRpm = (SWORD)MC_UpcInfo.stMotorInfo.uwRSpdRpm;
-            cp_stMotorPara.swRPwrWt = (SWORD)MC_UpcInfo.stMotorInfo.uwRPwrWt;
-            cp_stMotorPara.swRIarmsA = (SWORD)MC_UpcInfo.stMotorInfo.uwRCurA;
-            cp_stMotorPara.swRUdcV = (SWORD)MC_UpcInfo.stMotorInfo.uwRVolV;
-            cp_stMotorPara.swJD = (SWORD)MC_UpcInfo.stMotorInfo.uwJD;
-            cp_stMotorPara.swTorMax = (SWORD)MC_UpcInfo.stMotorInfo.uwTorMaxNm;
-
-            cp_stFlg.ParaMotorDriveUpdateFinishFlg = TRUE;
-            cp_stFlg.ParaMInfoUpdateFlg = FALSE;
-        }
-
-        if (cp_stFlg.ParaBikeInfoUpdateFlg == TRUE)
-        {
-            ass_stParaCong.uwWheelPerimeter = MC_UpcInfo.stBikeInfo.uwWheelPerimeter;
-            ass_stParaCong.uwMechRationMotor = MC_UpcInfo.stBikeInfo.uwMechRationMotor;
-            ass_stParaCong.uwAssistMaxSpdKmH = MC_UpcInfo.stBikeInfo.uwAssistMaxSpdKmH;
-            ass_stParaCong.uwThrottleMaxSpdKmH = MC_UpcInfo.stBikeInfo.uwThrottleMaxSpdKmH;
-            ass_stParaCong.uwNmFrontChainring = MC_UpcInfo.stBikeInfo.uwNmFrontChainring;
-            ass_stParaCong.uwNmBackChainring = MC_UpcInfo.stBikeInfo.uwNmBackChainring;
-            ass_stParaCong.uwAssistSelect1 = MC_UpcInfo.stBikeInfo.uwAssistSelect1;
-            ass_stParaCong.uwAssistSelect2 = MC_UpcInfo.stBikeInfo.uwAssistSelect2;
-            ass_stParaCong.uwLightVoltage = MC_UpcInfo.stBikeInfo.uwLightVoltage;
-            ass_stParaCong.swDeltPerimeter = MC_UpcInfo.stBikeInfo.swWheelSizeAdjust;
-            ass_stParaCong.uwStartMode = MC_UpcInfo.stBikeInfo.uwStartMode;
-            ass_stParaCong.uwAutoPowerOffTime = MC_UpcInfo.stBikeInfo.uwAutoPowerOffTime;
-
-            cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
-            cp_stFlg.ParaBikeInfoUpdateFlg = FALSE;
-        }
+        cp_stMotorPara.swMotrPolePairs = (SWORD)MC_UpcInfo.stMotorInfo.uwPolePairs;
+        cp_stMotorPara.swRsOhm = (SWORD)MC_UpcInfo.stMotorInfo.uwRsmOhm;
+        cp_stMotorPara.swLdmH = (SWORD)MC_UpcInfo.stMotorInfo.uwLduH;
+        cp_stMotorPara.swLqmH = (SWORD)MC_UpcInfo.stMotorInfo.uwLquH;
+        cp_stMotorPara.swFluxWb = (SWORD)MC_UpcInfo.stMotorInfo.uwFluxmWb;
+        cp_stMotorPara.swIdMaxA = (SWORD)MC_UpcInfo.stMotorInfo.uwIdMaxA;
+        cp_stMotorPara.swIdMinA = (SWORD)MC_UpcInfo.stMotorInfo.uwIdMinA;
+        cp_stMotorPara.swRSpeedRpm = (SWORD)MC_UpcInfo.stMotorInfo.uwRSpdRpm;
+        cp_stMotorPara.swRPwrWt = (SWORD)MC_UpcInfo.stMotorInfo.uwRPwrWt;
+        cp_stMotorPara.swRIarmsA = (SWORD)MC_UpcInfo.stMotorInfo.uwRCurA;
+        cp_stMotorPara.swRUdcV = (SWORD)MC_UpcInfo.stMotorInfo.uwRVolV;
+        cp_stMotorPara.swJD = (SWORD)MC_UpcInfo.stMotorInfo.uwJD;
+        cp_stMotorPara.swTorMax = (SWORD)MC_UpcInfo.stMotorInfo.uwTorMaxNm;
+
+        cp_stFlg.ParaMotorDriveUpdateFinishFlg = TRUE;
+        cp_stFlg.ParaMInfoUpdateFlg = FALSE;
+    }
 
-        if (cp_stFlg.ParaMCInfoUpdateFlg == TRUE)
-        {
-            cp_stFlg.ParaFirstSetFlg = MC_UpcInfo.stTestParaInfo.uwEEFirstDefaultSetFlg;
-            cp_stFlg.SpiOffsetFirstSetFlg = MC_UpcInfo.stTestParaInfo.uwSPIOffsetFirstSetFlg;
-            spi_stResolverOut.swSpiThetaOffsetOrignPu = MC_UpcInfo.stMContorlInfo.uwSPIPosOffsetOrigin;
-            spi_stResolverOut.swSpiThetaOffsetPu = MC_UpcInfo.stMContorlInfo.uwSPIPosOffsetNow;
-            cp_stMotorPara.swIpeakMaxA = (SWORD)MC_UpcInfo.stMContorlInfo.uwIPeakMaxA;
-            cp_stControlPara.swAlmOverCurrentVal = (SWORD)MC_UpcInfo.stMContorlInfo.uwAlamOCurA;
-            cp_stControlPara.swAlmOverVolVal3 = (SWORD)MC_UpcInfo.stMContorlInfo.uwAlamOVolV;
-            cp_stControlPara.swAlmUnderVolVal2 = (SWORD)MC_UpcInfo.stMContorlInfo.uwAlamUVolV;
-            cp_stControlPara.swAlmOverSpdVal = (SWORD)MC_UpcInfo.stMContorlInfo.uwAlamOverSpdRpm;
-            cp_stControlPara.swAlmOverHeatCeVal = (SWORD)MC_UpcInfo.stMContorlInfo.uwAlamOverHeatCe;
-            cp_stControlPara.swAlmRecOHeatVal = (SWORD)MC_UpcInfo.stMContorlInfo.uwAlamRecHeatCe;
-            cp_stControlPara.swAlmPwrLimitStartTempVal = (SWORD)MC_UpcInfo.stMContorlInfo.uwPwrLimitStartCe;
-
-            cp_stFlg.ParaMotorDriveUpdateFinishFlg = TRUE;
-            cp_stFlg.ParaMCInfoUpdateFlg = FALSE;
-        }
+    if (cp_stFlg.ParaBikeInfoUpdateFlg == TRUE)
+    {
+        ass_stParaCong.uwWheelPerimeter = MC_UpcInfo.stBikeInfo.uwWheelPerimeter;
+        ass_stParaCong.uwMechRationMotor = MC_UpcInfo.stBikeInfo.uwMechRationMotor;
+        ass_stParaCong.uwAssistMaxSpdKmH = MC_UpcInfo.stBikeInfo.uwAssistMaxSpdKmH;
+        ass_stParaCong.uwThrottleMaxSpdKmH = MC_UpcInfo.stBikeInfo.uwThrottleMaxSpdKmH;
+        ass_stParaCong.uwNmFrontChainring = MC_UpcInfo.stBikeInfo.uwNmFrontChainring;
+        ass_stParaCong.uwNmBackChainring = MC_UpcInfo.stBikeInfo.uwNmBackChainring;
+        ass_stParaCong.uwAssistSelect1 = MC_UpcInfo.stBikeInfo.uwAssistSelect1;
+        ass_stParaCong.uwAssistSelect2 = MC_UpcInfo.stBikeInfo.uwAssistSelect2;
+        ass_stParaCong.uwLightVoltage = MC_UpcInfo.stBikeInfo.uwLightVoltage;
+        ass_stParaCong.swDeltPerimeter = MC_UpcInfo.stBikeInfo.swWheelSizeAdjust;
+        ass_stParaCong.uwStartMode = MC_UpcInfo.stBikeInfo.uwStartMode;
+        ass_stParaCong.uwAutoPowerOffTime = MC_UpcInfo.stBikeInfo.uwAutoPowerOffTime;
+
+        cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
+        cp_stFlg.ParaBikeInfoUpdateFlg = FALSE;
+    }
 
-        if (cp_stFlg.ParaSensorInfoUpdateFlg == TRUE)
-        {
-            torsensor_stTorSensorCof.uwTorqueOffsetOrign = MC_UpcInfo.stSensorInfo.uwTorSensorOffsetOrigin;
-            torsensor_stTorSensorCof.uwMaxSensorTorquePu = MC_UpcInfo.stSensorInfo.uwBikeTorMaxNm;
-            torsensor_stTorSensorCof.uwBikeTorStep1RealNm = MC_UpcInfo.stSensorInfo.uwBikeTor1StepRealNm;
-            torsensor_stTorSensorCof.uwBikeTorStep1ADC = MC_UpcInfo.stSensorInfo.uwBikeTor1StepADC;
-            torsensor_stTorSensorCof.uwBikeTorStep2RealNm = MC_UpcInfo.stSensorInfo.uwBikeTor2StepRealNm;
-            torsensor_stTorSensorCof.uwBikeTorStep2ADC = MC_UpcInfo.stSensorInfo.uwBikeTor2StepADC;
-            torsensor_stTorSensorCof.uwBikeTorStep3RealNm = MC_UpcInfo.stSensorInfo.uwBikeTor3StepRealNm;
-            torsensor_stTorSensorCof.uwBikeTorStep3ADC = MC_UpcInfo.stSensorInfo.uwBikeTor3StepADC;
-            torsensor_stTorSensorCof.uwBikeTorStep4RealNm = MC_UpcInfo.stSensorInfo.uwBikeTor4StepRealNm;
-            torsensor_stTorSensorCof.uwBikeTorStep4ADC = MC_UpcInfo.stSensorInfo.uwBikeTor4StepADC;
-            cadence_stFreGetCof.uwNumbersPulses = MC_UpcInfo.stSensorInfo.uwCadSensorPulseNm;
-            bikespeed_stFreGetCof.uwNumbersPulses = MC_UpcInfo.stSensorInfo.uwBikeSpdSensorPulseNm;
-
-            cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
-            cp_stFlg.ParaSensorInfoUpdateFlg = FALSE;
-        }
+    if (cp_stFlg.ParaMCInfoUpdateFlg == TRUE)
+    {
+        cp_stFlg.ParaFirstSetFlg = MC_UpcInfo.stTestParaInfo.uwEEFirstDefaultSetFlg;
+        cp_stFlg.SpiOffsetFirstSetFlg = MC_UpcInfo.stTestParaInfo.uwSPIOffsetFirstSetFlg;
+        spi_stResolverOut.swSpiThetaOffsetOrignPu = MC_UpcInfo.stMContorlInfo.uwSPIPosOffsetOrigin;
+        spi_stResolverOut.swSpiThetaOffsetPu = MC_UpcInfo.stMContorlInfo.uwSPIPosOffsetNow;
+        cp_stMotorPara.swIpeakMaxA = (SWORD)MC_UpcInfo.stMContorlInfo.uwIPeakMaxA;
+        cp_stControlPara.swAlmOverCurrentVal = (SWORD)MC_UpcInfo.stMContorlInfo.uwAlamOCurA;
+        cp_stControlPara.swAlmOverVolVal3 = (SWORD)MC_UpcInfo.stMContorlInfo.uwAlamOVolV;
+        cp_stControlPara.swAlmUnderVolVal2 = (SWORD)MC_UpcInfo.stMContorlInfo.uwAlamUVolV;
+        cp_stControlPara.swAlmOverSpdVal = (SWORD)MC_UpcInfo.stMContorlInfo.uwAlamOverSpdRpm;
+        cp_stControlPara.swAlmOverHeatCeVal = (SWORD)MC_UpcInfo.stMContorlInfo.uwAlamOverHeatCe;
+        cp_stControlPara.swAlmRecOHeatVal = (SWORD)MC_UpcInfo.stMContorlInfo.uwAlamRecHeatCe;
+        cp_stControlPara.swAlmPwrLimitStartTempVal = (SWORD)MC_UpcInfo.stMContorlInfo.uwPwrLimitStartCe;
+
+        cp_stFlg.ParaMotorDriveUpdateFinishFlg = TRUE;
+        cp_stFlg.ParaMCInfoUpdateFlg = FALSE;
+    }
 
-        if (cp_stFlg.ParaAInfoUpdateFlg == TRUE)
-        {
-            ass_stParaSet.uwStartupCoef = MC_UpcInfo.stAssistInfo.swStartupGain;
-            ass_stParaSet.uwStartupCruiseCoef = MC_UpcInfo.stAssistInfo.swStartcruiseGain;
-            ass_stParaSet.uwAssistStartNm = MC_UpcInfo.stAssistInfo.uwAssistStartNm;
-            ass_stParaSet.uwAssistStopNm = MC_UpcInfo.stAssistInfo.uwAssistStopNm;
-            ass_stParaSet.uwStartUpGainStep = MC_UpcInfo.stAssistInfo.uwStartUpGainStep;
-            ass_stParaSet.uwStartUpCadNm = MC_UpcInfo.stAssistInfo.uwStartUpCadNm;
-            ass_stParaSet.uwTorLPFCadNm = MC_UpcInfo.stAssistInfo.uwTorLPFCadNm;
-            ass_stParaSet.uwSpeedAssistSpdRpm = MC_UpcInfo.stAssistInfo.uwSpeedAssistSpdRpm;
-            ass_stParaSet.uwSpeedAssistIMaxA = MC_UpcInfo.stAssistInfo.uwSpeedAssistIMaxA;
-            ass_stParaSet.uwAssistLimitBikeSpdStart = MC_UpcInfo.stAssistInfo.uwAssistLimitBikeSpdStart;
-            ass_stParaSet.uwAssistLimitBikeSpdStop = MC_UpcInfo.stAssistInfo.uwAssistLimitBikeSpdStop;
-            ass_stParaSet.uwCadenceWeight = MC_UpcInfo.stAssistInfo.uwCadenceAssistWeight;
-//            ass_stParaSet.uwTorWeight = Q12_1 - ass_stParaSet.uwCadenceWeight;
-
-            cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
-            cp_stFlg.ParaAInfoUpdateFlg = FALSE;
-        }
+    if (cp_stFlg.ParaSensorInfoUpdateFlg == TRUE)
+    {
+        torsensor_stTorSensorCof.uwTorqueOffsetOrign = MC_UpcInfo.stSensorInfo.uwTorSensorOffsetOrigin;
+        torsensor_stTorSensorCof.uwMaxSensorTorquePu = MC_UpcInfo.stSensorInfo.uwBikeTorMaxNm;
+        torsensor_stTorSensorCof.uwBikeTorStep1RealNm = MC_UpcInfo.stSensorInfo.uwBikeTor1StepRealNm;
+        torsensor_stTorSensorCof.uwBikeTorStep1ADC = MC_UpcInfo.stSensorInfo.uwBikeTor1StepADC;
+        torsensor_stTorSensorCof.uwBikeTorStep2RealNm = MC_UpcInfo.stSensorInfo.uwBikeTor2StepRealNm;
+        torsensor_stTorSensorCof.uwBikeTorStep2ADC = MC_UpcInfo.stSensorInfo.uwBikeTor2StepADC;
+        torsensor_stTorSensorCof.uwBikeTorStep3RealNm = MC_UpcInfo.stSensorInfo.uwBikeTor3StepRealNm;
+        torsensor_stTorSensorCof.uwBikeTorStep3ADC = MC_UpcInfo.stSensorInfo.uwBikeTor3StepADC;
+        torsensor_stTorSensorCof.uwBikeTorStep4RealNm = MC_UpcInfo.stSensorInfo.uwBikeTor4StepRealNm;
+        torsensor_stTorSensorCof.uwBikeTorStep4ADC = MC_UpcInfo.stSensorInfo.uwBikeTor4StepADC;
+        cadence_stFreGetCof.uwNumbersPulses = MC_UpcInfo.stSensorInfo.uwCadSensorPulseNm;
+        bikespeed_stFreGetCof.uwNumbersPulses = MC_UpcInfo.stSensorInfo.uwBikeSpdSensorPulseNm;
+
+        cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
+        cp_stFlg.ParaSensorInfoUpdateFlg = FALSE;
+    }
 
-        if(cp_stFlg.TestParaInfoUpdateFlg == TRUE)
-        {
-            cp_stControlPara.swAlignCurAp = (SWORD)MC_UpcInfo.stTestParaInfo.uwInitPosCurAmp;
-            cp_stControlPara.swDragVolAp = (SWORD)MC_UpcInfo.stTestParaInfo.uwVFControlVolAmp;
-            cp_stControlPara.swDragCurAp = (SWORD)MC_UpcInfo.stTestParaInfo.uwIFControlCurAmp;
-            cp_stControlPara.swDragSpdHz = (SWORD)MC_UpcInfo.stTestParaInfo.uwVFIFTargetFreHz;
-
-            cp_stControlPara.swSpeedAccRate = (SWORD)MC_UpcInfo.stTestParaInfo.uwSpeedLoopAccRate;
-            cp_stControlPara.swSpeedDccRate = (SWORD)MC_UpcInfo.stTestParaInfo.uwSpeedLoopDecRate;
-            cp_stControlPara.swAsrPIBandwidth = (SWORD)MC_UpcInfo.stTestParaInfo.uwSpeedLoopBandWidthHz;
-            cp_stControlPara.swAsrPIM = (SWORD)MC_UpcInfo.stTestParaInfo.uwSpeedLoopCoefM;
-
-            cp_stControlPara.swAcrPIBandwidth = (SWORD)MC_UpcInfo.stTestParaInfo.uwCuerrentLoopBandWidthHz;
-            cp_stControlPara.swAcrRaCoef = (SWORD)MC_UpcInfo.stTestParaInfo.uwCurrentLoopCoefM;
-
-            cp_stControlPara.swObsFluxPICrossfreHz = (SWORD)MC_UpcInfo.stTestParaInfo.uwFluxObsBandWidthHz;
-            cp_stControlPara.swObsFluxPIDampratio = (SWORD)MC_UpcInfo.stTestParaInfo.uwFluxObsCoefM;
-            cp_stControlPara.swObsSpdPLLBandWidthHz = (SWORD)MC_UpcInfo.stTestParaInfo.uwThetaObsPLLBandWidthHz;
-            cp_stControlPara.swObsSpdPLLM = (SWORD)MC_UpcInfo.stTestParaInfo.uwThetaObsPLLCoefM;
-
-            cp_stMotorPara.swJD = (SWORD)MC_UpcInfo.stTestParaInfo.uwJm;
-            cp_stControlPara.swPWMMaxDuty = (SWORD)MC_UpcInfo.stTestParaInfo.uwPWMMaxDuty;
-            cp_stControlPara.swPWM7to5Duty = (SWORD)MC_UpcInfo.stTestParaInfo.uwPWM7to5Duty;
-            cp_stControlPara.swPwrLimitValWt = (SWORD)MC_UpcInfo.stTestParaInfo.uwPwrLimit;
-            cp_stControlPara.swPwrLimitErrWt =(SWORD) MC_UpcInfo.stTestParaInfo.uwPwrLimitError;
-            cp_stControlPara.swPwrLimitKpPu = (SWORD)MC_UpcInfo.stTestParaInfo.uwPwrLimitKp;
-            cp_stControlPara.swPwrLimitKiPu = (SWORD)MC_UpcInfo.stTestParaInfo.uwPwrLimitKi;
-
-            cp_stFlg.ParaMotorDriveUpdateFinishFlg = TRUE;
-            // cp_stFlg.TestParaInfoUpdateFlg = FALSE;
-        }
+    if (cp_stFlg.ParaAInfoUpdateFlg == TRUE)
+    {
+        ass_stParaSet.uwStartupCoef = MC_UpcInfo.stAssistInfo.swStartupGain;
+        ass_stParaSet.uwStartupCruiseCoef = MC_UpcInfo.stAssistInfo.swStartcruiseGain;
+        ass_stParaSet.uwAssistStartNm = MC_UpcInfo.stAssistInfo.uwAssistStartNm;
+        ass_stParaSet.uwAssistStopNm = MC_UpcInfo.stAssistInfo.uwAssistStopNm;
+        ass_stParaSet.uwStartUpGainStep = MC_UpcInfo.stAssistInfo.uwStartUpGainStep;
+        ass_stParaSet.uwStartUpCadNm = MC_UpcInfo.stAssistInfo.uwStartUpCadNm;
+        ass_stParaSet.uwTorLPFCadNm = MC_UpcInfo.stAssistInfo.uwTorLPFCadNm;
+        ass_stParaSet.uwSpeedAssistSpdRpm = MC_UpcInfo.stAssistInfo.uwSpeedAssistSpdRpm;
+        ass_stParaSet.uwSpeedAssistIMaxA = MC_UpcInfo.stAssistInfo.uwSpeedAssistIMaxA;
+        ass_stParaSet.uwAssistLimitBikeSpdStart = MC_UpcInfo.stAssistInfo.uwAssistLimitBikeSpdStart;
+        ass_stParaSet.uwAssistLimitBikeSpdStop = MC_UpcInfo.stAssistInfo.uwAssistLimitBikeSpdStop;
+        ass_stParaSet.uwCadenceWeight = MC_UpcInfo.stAssistInfo.uwCadenceAssistWeight;
+        // ass_stParaSet.uwTorWeight = Q12_1 - ass_stParaSet.uwCadenceWeight;
+
+        cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
+        cp_stFlg.ParaAInfoUpdateFlg = FALSE;
+    }
 
-        cp_stFlg.ParaUpdateFlg = FALSE;
+    if(cp_stFlg.TestParaInfoUpdateFlg == TRUE)
+    {
+        cp_stControlPara.swAlignCurAp = (SWORD)MC_UpcInfo.stTestParaInfo.uwInitPosCurAmp;
+        cp_stControlPara.swDragVolAp = (SWORD)MC_UpcInfo.stTestParaInfo.uwVFControlVolAmp;
+        cp_stControlPara.swDragCurAp = (SWORD)MC_UpcInfo.stTestParaInfo.uwIFControlCurAmp;
+        cp_stControlPara.swDragSpdHz = (SWORD)MC_UpcInfo.stTestParaInfo.uwVFIFTargetFreHz;
+
+        cp_stControlPara.swSpeedAccRate = (SWORD)MC_UpcInfo.stTestParaInfo.uwSpeedLoopAccRate;
+        cp_stControlPara.swSpeedDccRate = (SWORD)MC_UpcInfo.stTestParaInfo.uwSpeedLoopDecRate;
+        cp_stControlPara.swAsrPIBandwidth = (SWORD)MC_UpcInfo.stTestParaInfo.uwSpeedLoopBandWidthHz;
+        cp_stControlPara.swAsrPIM = (SWORD)MC_UpcInfo.stTestParaInfo.uwSpeedLoopCoefM;
+
+        cp_stControlPara.swAcrPIBandwidth = (SWORD)MC_UpcInfo.stTestParaInfo.uwCuerrentLoopBandWidthHz;
+        cp_stControlPara.swAcrRaCoef = (SWORD)MC_UpcInfo.stTestParaInfo.uwCurrentLoopCoefM;
+
+        cp_stControlPara.swObsFluxPICrossfreHz = (SWORD)MC_UpcInfo.stTestParaInfo.uwFluxObsBandWidthHz;
+        cp_stControlPara.swObsFluxPIDampratio = (SWORD)MC_UpcInfo.stTestParaInfo.uwFluxObsCoefM;
+        cp_stControlPara.swObsSpdPLLBandWidthHz = (SWORD)MC_UpcInfo.stTestParaInfo.uwThetaObsPLLBandWidthHz;
+        cp_stControlPara.swObsSpdPLLM = (SWORD)MC_UpcInfo.stTestParaInfo.uwThetaObsPLLCoefM;
+
+        cp_stMotorPara.swJD = (SWORD)MC_UpcInfo.stTestParaInfo.uwJm;
+        cp_stControlPara.swPWMMaxDuty = (SWORD)MC_UpcInfo.stTestParaInfo.uwPWMMaxDuty;
+        cp_stControlPara.swPWM7to5Duty = (SWORD)MC_UpcInfo.stTestParaInfo.uwPWM7to5Duty;
+        cp_stControlPara.swPwrLimitValWt = (SWORD)MC_UpcInfo.stTestParaInfo.uwPwrLimit;
+        cp_stControlPara.swPwrLimitErrWt =(SWORD) MC_UpcInfo.stTestParaInfo.uwPwrLimitError;
+        cp_stControlPara.swPwrLimitKpPu = (SWORD)MC_UpcInfo.stTestParaInfo.uwPwrLimitKp;
+        cp_stControlPara.swPwrLimitKiPu = (SWORD)MC_UpcInfo.stTestParaInfo.uwPwrLimitKi;
+
+        cp_stFlg.ParaMotorDriveUpdateFinishFlg = TRUE;
+        // cp_stFlg.TestParaInfoUpdateFlg = FALSE;
     }
+
+    cp_stFlg.ParaUpdateFlg = FALSE;
 }
 /***************************************************************
  Function: mn_voSoftwareInit;

User project/2.MotorDrive/Source/alarm.c

@@ -1290,8 +1290,6 @@ void alm_voDetec200MS(const ALM_BIKE_IN *in, const ALM_DETEC200MS_COF *coef) /*
     {
         alm_stDecCt.uwCadenceFlt = 0;
     }
-
-    
     
     /* Bike torque sensor fault */
     if((in->uwTroqReg < coef->uwTorqMinReg) || (in->uwTroqReg >= coef->uwTorqMaxReg)) //Fault: U_Torq < 0.1V or  >=3V

User project/3.BasicFunction/Include/canAppl.h

@@ -17,6 +17,10 @@
 
 #include "typedefine.h"
 #include "gd32f30x.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
 /****************************************
  *
  *          Definitions & Macros
@@ -730,6 +734,14 @@ void Can_AssistCoef_Read(const UPC_CurveOrderInfo_Struct_t *order);
  *
  */
 void Can_AssistCoef_Write(const UPC_CurveOrderInfo_Struct_t *order);
+
+/************************************************************************
+ Flag Define (N/A)
+*************************************************************************/
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
 #endif
 
 /************************************************************************

User project/3.BasicFunction/Include/torquesensor.h

@@ -16,6 +16,10 @@
 #define TORQUESENSOR_H
 
 #include "typedefine.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
 /****************************************
  *
  *          Definitions & Macros
@@ -43,7 +47,7 @@
     } // Default value of CADENCE_OUT
 #define TORQUESENSOR_COF_DEFAULT                                         \
     {                                                                    \
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, FALSE, FALSE, 1,1,2,2,3,3,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0 \
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, FALSE, FALSE, 1,1,2,2,3,3,4,4,0,0,0,0,0,0,0,0,0,0 \
     } // Default value of CADENCE_OUT
 
 #define TORQUESENSITIVE_COF_DEFAULT                                         \
@@ -110,10 +114,6 @@ typedef struct
     UWORD uwBikeTorStep4NmPu;
 
     UWORD uwSensorVolPerTorqDefault;
-    UWORD uwSensorVolPerTorq1; // mV/Nm,the output gain1
-    UWORD uwSensorVolPerTorq2; // mV/Nm,the output gain2
-    UWORD uwSensorVolPerTorq3; // mV/Nm,the output gain3
-    UWORD uwSensorVolPerTorq4; // mV/Nm,the output gain4
 
     ULONG ulTorqueReg2PuDefault;
     ULONG ulTorqueReg2Pu1; // Gain1 of register to Pu
@@ -145,6 +145,10 @@ void torsensor_voCadenceCnt(void);
 void torsensor_voDynamicOffset(void);
 void torsensor_voOffsetUpdate(void);
 /************************************************************************/
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
 #endif
 /************************************************************************
  End of this File (EOF):

User project/3.BasicFunction/Source/torquesensor.c

@@ -13,20 +13,23 @@
  Beginning of File, do not put anything above here except notes
  Compiler Directives:
 *************************************************************************/
+#include "torquesensor.h"
 #include "syspar.h"
-#include "typedefine.h"
 #include "mathtool.h"
-#include "torquesensor.h"
 #include "hwsetup.h"
 #include "CodePara.h"
 #include "canAppl.h"
 #include "FuncLayerAPI.h"
+
+#ifdef RUN_ARCH_SIM
+#include "test_user.h"
+#endif
 /******************************
  *
  * static  Parameter
  *
  ******************************/
-static LPF_OUT   scm_stTorSensorLpf;
+static LPF_OUT   torq_pvt_stTorSensorLpf;
 static volatile SWORD TorqOffsetReg[TORQ_OFFSET_NUM]= {
 640,    //-11 C
 718,    //8 C
@@ -93,8 +96,8 @@ TORQUESENSOR_OUT torsensor_stTorSensorOut = TORQUESENSOR_OUT_DEFAULT;
 void torsensor_voTorSensorCof(void)
 {
     ULONG ulLpfTm = 0;
-    UWORD i = 0;
-      
+    UWORD i = 0, uwAverageOffset = 0;
+
     // torsensor_stTorSensorCof.uwMaxSensorTorquePu = ((ULONG)TORQUE_MAX_RANGE << 14) / TORQUEBASE; // Q14
     torsensor_stTorSensorCof.uwMinSensorTorquePu = ((ULONG)TORQUE_MIN_RANGE << 14) / TORQUEBASE; // Q14
     torsensor_stTorSensorCof.uwMaxSensorVolOutputPu = (ULONG)TORQUE_VOLTAGE_MAX_RANGE << 14 / VBASE;
@@ -104,11 +107,11 @@ void torsensor_voTorSensorCof(void)
 
     if(torsensor_stTorSensorCof.uwTorqueOffsetConfirmFlg == FALSE)
     {
-        #if (TORSENSOR_USEMOL == TORSENSOR_USEDEFAULT)
+#if (TORSENSOR_USEMOL == TORSENSOR_USEDEFAULT)
         torsensor_stTorSensorCof.uwTorqueOffset = TORQUE_VOLTAGE_MIN_RANGE * 4096 / 3300;
-        #elif (TORSENSOR_USEMOL == TORSENSOR_USEEE)
-         torsensor_stTorSensorCof.uwTorqueOffsetPowerUp = hw_uwADC0[7]; 
-        //torsensor_stTorSensorCof.uwTorqueOffsetPowerUp = PowerUpOffset;
+
+#elif (TORSENSOR_USEMOL == TORSENSOR_USEEE)
+        torsensor_stTorSensorCof.uwTorqueOffsetPowerUp = hw_uwADC0[7]; 
 
         if(torsensor_stTorSensorCof.uwTorqueOffsetNow1 != 0 && torsensor_stTorSensorCof.uwTorqueOffsetNow2 != 0
             && torsensor_stTorSensorCof.uwTorqueOffsetNow3 != 0 && torsensor_stTorSensorCof.uwTorqueOffsetNow4 != 0)
@@ -127,57 +130,21 @@ void torsensor_voTorSensorCof(void)
             MC_UpcInfo.stSensorInfo.uwSaveFlg = 1;
         }
         else
-        {
-            UWORD AverageOffset = 0;
-//            AverageOffset = ((SLONG)torsensor_stTorSensorCof.uwTorqueOffsetNow1 + torsensor_stTorSensorCof.uwTorqueOffsetNow2 + 
-//                            torsensor_stTorSensorCof.uwTorqueOffsetNow3 + torsensor_stTorSensorCof.uwTorqueOffsetNow4)>>2;
-//            if( ((SWORD)torsensor_stTorSensorCof.uwTorqueOffsetPowerUp - torsensor_stTorSensorCof.uwTorqueOffsetOrign) > 200 )
-//            {
-//            }
-//            else
-//            {
-//                torsensor_stTorSensorCof.uwTorqueOffsetNow1 = torsensor_stTorSensorCof.uwTorqueOffsetNow2;
-//                torsensor_stTorSensorCof.uwTorqueOffsetNow2 = torsensor_stTorSensorCof.uwTorqueOffsetNow3;
-//                torsensor_stTorSensorCof.uwTorqueOffsetNow3 = torsensor_stTorSensorCof.uwTorqueOffsetNow4;
-//                torsensor_stTorSensorCof.uwTorqueOffsetNow4 = torsensor_stTorSensorCof.uwTorqueOffsetPowerUp;
-//
-//                cp_stFlg.ParaSaveEEFlg = TRUE;
-//                cp_stFlg.ParaUpdateFlg = TRUE;
-//                //cp_stFlg.ParaSensorInfoUpdateFlg = TRUE;
-//                //cp_stFlg.ParaAssistUpdateFinishFlg = TRUE;
-//                MC_UpcInfo.stSensorInfo.uwSaveFlg = TRUE;
-//            }
-//
-//            if( torsensor_stTorSensorCof.uwTorqueNowAllHasValueFlg == TRUE )
-//            {
-//                if((AverageOffset - torsensor_stTorSensorCof.uwTorqueOffsetOrign)>400 || (AverageOffset - torsensor_stTorSensorCof.uwTorqueOffsetOrign)<-400)
-//                {
-//                    torsensor_stTorSensorCof.uwTorqueOffset = torsensor_stTorSensorCof.uwTorqueOffsetOrign;
-//                }
-//                else
-//                {
-//                    torsensor_stTorSensorCof.uwTorqueOffset = AverageOffset;       
-//                }
-//            }
-//            else
-//            {
-//                torsensor_stTorSensorCof.uwTorqueOffset = torsensor_stTorSensorCof.uwTorqueOffsetOrign;
-//            }
-            
-            
+        { 
             /* Compare with AvgOffset */ 
             if(torsensor_stTorSensorCof.uwTorqueNowAllHasValueFlg == TRUE)
             {
-                AverageOffset = (UWORD)(((ULONG)torsensor_stTorSensorCof.uwTorqueOffsetNow1 + torsensor_stTorSensorCof.uwTorqueOffsetNow2 +
+                uwAverageOffset = (UWORD)(((ULONG)torsensor_stTorSensorCof.uwTorqueOffsetNow1 + torsensor_stTorSensorCof.uwTorqueOffsetNow2 +
                                 torsensor_stTorSensorCof.uwTorqueOffsetNow3 + torsensor_stTorSensorCof.uwTorqueOffsetNow4)>>2);
             }
             else
             {
-                AverageOffset = torsensor_stTorSensorCof.uwTorqueOffsetOrign;
+                uwAverageOffset = torsensor_stTorSensorCof.uwTorqueOffsetOrign;
             }            
-            if(abs((SWORD)torsensor_stTorSensorCof.uwTorqueOffsetPowerUp - AverageOffset) > 200)   
+
+            if(abs((SWORD)torsensor_stTorSensorCof.uwTorqueOffsetPowerUp - (SWORD)uwAverageOffset) > 200)   
             {
-                torsensor_stTorSensorCof.uwTorqueOffset = AverageOffset;
+                torsensor_stTorSensorCof.uwTorqueOffset = uwAverageOffset;
             }
             else
             {
@@ -194,44 +161,25 @@ void torsensor_voTorSensorCof(void)
 
                 torsensor_stTorSensorCof.uwTorqueOffset = torsensor_stTorSensorCof.uwTorqueOffsetPowerUp;  
             }
-
         }
-        #endif
+#endif
         torsensor_stTorSensorCof.uwTorqueOffsetConfirmFlg = TRUE;
     }
-    torsensor_stTorSensorCof.uwSensorVolPerTorqDefault = TORQUE_VOLTAGE_PER_NM;
-    
-    torsensor_stTorSensorCof.uwSensorVolPerTorq1 =
-        (UWORD)((((ULONG)3300 * (torsensor_stTorSensorCof.uwBikeTorStep1ADC - torsensor_stTorSensorCof.uwTorqueOffset)) >> 12) *10 *10/
-        (torsensor_stTorSensorCof.uwBikeTorStep1RealNm - 0));
-    
-    torsensor_stTorSensorCof.uwSensorVolPerTorq2 =
-    		(UWORD)((((ULONG)3300 * (torsensor_stTorSensorCof.uwBikeTorStep2ADC - torsensor_stTorSensorCof.uwBikeTorStep1ADC)) >> 12) *10 *10/
-        (torsensor_stTorSensorCof.uwBikeTorStep2RealNm - torsensor_stTorSensorCof.uwBikeTorStep1RealNm));
     
-    torsensor_stTorSensorCof.uwSensorVolPerTorq3 =
-    		(UWORD)((((ULONG)3300 * (torsensor_stTorSensorCof.uwBikeTorStep3ADC - torsensor_stTorSensorCof.uwBikeTorStep2ADC)) >> 12) *10 *10/
-        (torsensor_stTorSensorCof.uwBikeTorStep3RealNm - torsensor_stTorSensorCof.uwBikeTorStep2RealNm));
-    
-    torsensor_stTorSensorCof.uwSensorVolPerTorq4 =
-    		(UWORD)((((ULONG)3300 * (torsensor_stTorSensorCof.uwBikeTorStep4ADC - torsensor_stTorSensorCof.uwBikeTorStep3ADC)) >> 12) *10*10 /
-        (torsensor_stTorSensorCof.uwBikeTorStep4RealNm - torsensor_stTorSensorCof.uwBikeTorStep3RealNm));
+    torsensor_stTorSensorCof.uwSensorVolPerTorqDefault = TORQUE_VOLTAGE_PER_NM;
 
     torsensor_stTorSensorCof.ulTorqueReg2PuDefault = (ULONG)((((UQWORD)33 << 24) / 10) / (1 << ADC_RESOLUTION_BIT) / TORQUE_VOLTAGE_SEN2MCUGAIN * 100 * 1000 /
                                                      torsensor_stTorSensorCof.uwSensorVolPerTorqDefault / TORQUEBASE *
                                                      10); // 3.3/4096/harwaregain/VolPerNm/TorqueBase;
-    torsensor_stTorSensorCof.ulTorqueReg2Pu1 = (ULONG)((((UQWORD)33 << 24) / 10) / (1 << ADC_RESOLUTION_BIT) / TORQUE_VOLTAGE_SEN2MCUGAIN * 100 * 1000 /
-                                               torsensor_stTorSensorCof.uwSensorVolPerTorq1 / TORQUEBASE *
-                                               10*10); // 3.3/4096/harwaregain/VolPerNm/TorqueBase;
-    torsensor_stTorSensorCof.ulTorqueReg2Pu2 = (ULONG)((((UQWORD)33 << 24) / 10) / (1 << ADC_RESOLUTION_BIT) / TORQUE_VOLTAGE_SEN2MCUGAIN * 100 * 1000 /
-                                               torsensor_stTorSensorCof.uwSensorVolPerTorq2 / TORQUEBASE *
-                                               10*10); // 3.3/4096/harwaregain/VolPerNm/TorqueBase;
-    torsensor_stTorSensorCof.ulTorqueReg2Pu3 = (ULONG)((((UQWORD)33 << 24) / 10) / (1 << ADC_RESOLUTION_BIT) / TORQUE_VOLTAGE_SEN2MCUGAIN * 100 * 1000 /
-                                               torsensor_stTorSensorCof.uwSensorVolPerTorq3 / TORQUEBASE *
-                                               10*10); // 3.3/4096/harwaregain/VolPerNm/TorqueBase;
-    torsensor_stTorSensorCof.ulTorqueReg2Pu4 = (ULONG)((((UQWORD)33 << 24) / 10) / (1 << ADC_RESOLUTION_BIT) / TORQUE_VOLTAGE_SEN2MCUGAIN * 100 * 1000 /
-                                               torsensor_stTorSensorCof.uwSensorVolPerTorq4 / TORQUEBASE *
-                                               10*10); // 3.3/4096/harwaregain/VolPerNm/TorqueBase;
+
+    torsensor_stTorSensorCof.ulTorqueReg2Pu1 = (ULONG)(((UQWORD)(torsensor_stTorSensorCof.uwBikeTorStep1RealNm - 0) << 24) / 
+                                               (torsensor_stTorSensorCof.uwBikeTorStep1ADC - torsensor_stTorSensorCof.uwTorqueOffset) /TORQUEBASE);
+    torsensor_stTorSensorCof.ulTorqueReg2Pu2 = (ULONG)(((UQWORD)(torsensor_stTorSensorCof.uwBikeTorStep2RealNm - torsensor_stTorSensorCof.uwBikeTorStep1RealNm) << 24) / 
+                                               (torsensor_stTorSensorCof.uwBikeTorStep2ADC - torsensor_stTorSensorCof.uwBikeTorStep1ADC) /TORQUEBASE);        
+    torsensor_stTorSensorCof.ulTorqueReg2Pu3 = (ULONG)(((UQWORD)(torsensor_stTorSensorCof.uwBikeTorStep3RealNm - torsensor_stTorSensorCof.uwBikeTorStep2RealNm) << 24) / 
+                                               (torsensor_stTorSensorCof.uwBikeTorStep3ADC - torsensor_stTorSensorCof.uwBikeTorStep2ADC) /TORQUEBASE);
+    torsensor_stTorSensorCof.ulTorqueReg2Pu4 = (ULONG)(((UQWORD)(torsensor_stTorSensorCof.uwBikeTorStep4RealNm - torsensor_stTorSensorCof.uwBikeTorStep3RealNm) << 24) / 
+                                               (torsensor_stTorSensorCof.uwBikeTorStep4ADC - torsensor_stTorSensorCof.uwBikeTorStep3ADC) /TORQUEBASE);
     
     torsensor_stTorSensorCof.uwBikeTorStep1NmPu = (UWORD)(((ULONG)torsensor_stTorSensorCof.uwBikeTorStep1RealNm << 14)/TORQUEBASE);
     torsensor_stTorSensorCof.uwBikeTorStep2NmPu = (UWORD)(((ULONG)torsensor_stTorSensorCof.uwBikeTorStep2RealNm << 14)/TORQUEBASE);
@@ -240,8 +188,9 @@ void torsensor_voTorSensorCof(void)
     
     /* Torque Sensor limit coef */
     ulLpfTm = 1000000 / torsensor_stTorSensorCof.uwTorSensorLPFFrq;
-    mth_voLPFilterCoef(ulLpfTm, torsensor_stTorSensorCof.uwTorVolLPFDisFrq, &scm_stTorSensorLpf.uwKx);
+    mth_voLPFilterCoef(ulLpfTm, torsensor_stTorSensorCof.uwTorVolLPFDisFrq, &torq_pvt_stTorSensorLpf.uwKx);
     
+    /* Torque Offset Correction Coef */
 //    for (i = 0; i < (TORQ_OFFSET_NUM - 1); i++)
 //    {
 //        TorqOffsetCof[i] =  (((SLONG)TorqOffsetReg[i+1] - (SLONG)TorqOffsetReg[i]) << 12) /(TorqOffsetTemp[i+1] - TorqOffsetTemp[i]); //Q12
@@ -273,55 +222,54 @@ void torsensor_voTorSensorInit(void)
     torsensor_stTorSensorOut.blTorqueCaliFlg = FALSE;
     torsensor_stTorSensorOut.blTorqueErrorFlg = FALSE;
     mth_voLPFilterCoef(1000000 / 1, EVENT_1MS_HZ, &tst_dynOffsetLpf.uwKx); //25Hz  
+    
     tstdynOffset= hw_uwADC0[7];
     tst_dynOffsetLpf.slY.sw.hi =  (SWORD)hw_uwADC0[7];
-        /* Torque Sensor limit coef */
-   
 }
 
 /*************************************************************************
  Local Functions (N/A)
 *************************************************************************/
-static BOOL tstDynCalibflg= TRUE;
-static UWORD tstTorqOffset,tstSensitiveset,TorqValue,TorqValuePu, TorqReg;
-static SWORD tstTorqTemp,tstTorqTemp111,tstSencitiveOrig;
-void torsensor_voCadenceCnt(void)
-{
-  if (((cadence_stFreGetCof.uwNumbersPulses>>1)-1) != tsttorqCadCnt)
-  {
-      tsttorqCadCnt++;
-  }
-  else
-  {
-      tsttorqCadCnt = 0;
-      tsttorqMin = 4096;
-  }
-}
+// static BOOL tstDynCalibflg= TRUE;
+// static UWORD tstTorqOffset,tstSensitiveset,TorqValue,TorqValuePu, TorqReg;
+// static SWORD tstTorqTemp,tstTorqTemp111,tstSencitiveOrig;
+// void torsensor_voCadenceCnt(void)
+// {
+//   if (((cadence_stFreGetCof.uwNumbersPulses>>1)-1) != tsttorqCadCnt)
+//   {
+//       tsttorqCadCnt++;
+//   }
+//   else
+//   {
+//       tsttorqCadCnt = 0;
+//       tsttorqMin = 4096;
+//   }
+// }
 
-void torsensor_voDynamicOffset(void)
-{
-   if(cadence_stFreGetOut.uwLPFFrequencyPu != 0)
-   {
-     tstDynCalibflg = TRUE;
-     if(tsttorqMin > hw_uwADC0[7])
-     {
-        tsttorqMin = hw_uwADC0[7];
-     }
-     if(tsttorqCadCnt == ((cadence_stFreGetCof.uwNumbersPulses>>1) -1))
-     {       
-        tstdynOffset = tsttorqMin;
-     }
-   }
-   else
-   {
-     if( tstDynCalibflg == TRUE && TorqValuePu <= 500)
-     {
-        tstdynOffset = hw_uwADC0[7];
-        tstDynCalibflg = FALSE;
-     }
-   }
-   mth_voLPFilter((SWORD)tstdynOffset, &tst_dynOffsetLpf);
-}
+// void torsensor_voDynamicOffset(void)
+// {
+//    if(cadence_stFreGetOut.uwLPFFrequencyPu != 0)
+//    {
+//      tstDynCalibflg = TRUE;
+//      if(tsttorqMin > hw_uwADC0[7])
+//      {
+//         tsttorqMin = hw_uwADC0[7];
+//      }
+//      if(tsttorqCadCnt == ((cadence_stFreGetCof.uwNumbersPulses>>1) -1))
+//      {       
+//         tstdynOffset = tsttorqMin;
+//      }
+//    }
+//    else
+//    {
+//      if( tstDynCalibflg == TRUE && TorqValuePu <= 500)
+//      {
+//         tstdynOffset = hw_uwADC0[7];
+//         tstDynCalibflg = FALSE;
+//      }
+//    }
+//    mth_voLPFilter((SWORD)tstdynOffset, &tst_dynOffsetLpf);
+// }
 
 
 //static void torsensor_voTorADCwithTemp(void)
@@ -380,8 +328,8 @@ void torsensor_voDynamicOffset(void)
 //            TorqValuePu = torsensor_stTorSensorCof.uwBikeTorStep4NmPu;
 //        }
 //        torsensor_stTorSensorOut.uwTorquePu=TorqValuePu;
-//        mth_voLPFilter(torsensor_stTorSensorOut.uwTorquePu, &scm_stTorSensorLpf);
-//        torsensor_stTorSensorOut.uwTorqueLPFPu = scm_stTorSensorLpf.slY.sw.hi;
+//        mth_voLPFilter(torsensor_stTorSensorOut.uwTorquePu, &torq_pvt_stTorSensorLpf);
+//        torsensor_stTorSensorOut.uwTorqueLPFPu = torq_pvt_stTorSensorLpf.slY.sw.hi;
 //        TorqValue = (ULONG)TorqValuePu * TORQUEBASE  >> 14;
 //        
 //    //TorqValue = ((torsensor_stTorSensorOut.uwTorqueReg - tstTorqOffset) << 12 )/tstSencitiveset;
@@ -397,7 +345,7 @@ void torsensor_voDynamicOffset(void)
 ****************************************************************/
 static UWORD tor_pvt_uwOffsetTarget = 0;
 static UWORD tor_pvt_uwOffsetMax = 0,tor_pvt_uwOffsetMin = 4096;
-static ULONG tor_pvt_ulCnt = 0;
+static ULONG tor_pvt_ulCnt = 0, tor_pvt_ulCnt2 = 0;
 void torsensor_voOffsetUpdate(void) 
 {
     SWORD swTorDelta;
@@ -407,7 +355,12 @@ void torsensor_voOffsetUpdate(void)
         swTorDelta = (SWORD)tor_pvt_uwOffsetMax - (SWORD)tor_pvt_uwOffsetMin;
         if(swTorDelta > 40)
         {   
-            tor_pvt_ulCnt = 0;              
+            tor_pvt_ulCnt = 0;   
+            tor_pvt_uwOffsetTarget = torsensor_stTorSensorCof.uwTorqueOffset;           
+        }
+        else 
+        {
+            tor_pvt_uwOffsetTarget = (tor_pvt_uwOffsetMax + tor_pvt_uwOffsetMin) >> 1;
         }
         tor_pvt_uwOffsetMax = 0;
         tor_pvt_uwOffsetMin = 4096; 
@@ -424,13 +377,12 @@ void torsensor_voOffsetUpdate(void)
             tor_pvt_uwOffsetMax = torsensor_stTorSensorOut.uwTorqueReg;
         }    
     }
-          
-    if(tor_pvt_ulCnt > TORQUE_90S_1MSCNT)
+
+    ++tor_pvt_ulCnt2;     
+    if(tor_pvt_ulCnt2 > TORQUE_90S_1MSCNT)
     {
-        swTorDelta = (SWORD)tor_pvt_uwOffsetMax - (SWORD)tor_pvt_uwOffsetMin;
-        if(swTorDelta < 40)
+        if(tor_pvt_uwOffsetTarget != torsensor_stTorSensorCof.uwTorqueOffset)
         {
-            tor_pvt_uwOffsetTarget = (tor_pvt_uwOffsetMax + tor_pvt_uwOffsetMin) >> 1;
             if(torsensor_stTorSensorCof.uwTorqueOffset < tor_pvt_uwOffsetTarget - 20)
             {
                 torsensor_stTorSensorCof.uwTorqueOffset += 20;
@@ -441,18 +393,14 @@ void torsensor_voOffsetUpdate(void)
             }
             else
             {
-               torsensor_stTorSensorCof.uwTorqueOffset = tor_pvt_uwOffsetTarget;
+                torsensor_stTorSensorCof.uwTorqueOffset = tor_pvt_uwOffsetTarget;
             }
             
-            torsensor_stTorSensorCof.uwSensorVolPerTorq1 =
-            		(UWORD)((((ULONG)3300 * (torsensor_stTorSensorCof.uwBikeTorStep1ADC - torsensor_stTorSensorCof.uwTorqueOffset)) >> 12) *10 *10/
-            (torsensor_stTorSensorCof.uwBikeTorStep1RealNm - 0));
-        
-            torsensor_stTorSensorCof.ulTorqueReg2Pu1 = (ULONG)((((SQWORD)33 << 24) / 10) / (1 << ADC_RESOLUTION_BIT) / TORQUE_VOLTAGE_SEN2MCUGAIN * 100 * 1000 /
-                                               torsensor_stTorSensorCof.uwSensorVolPerTorq1 / TORQUEBASE *
-                                               10*10); // 3.3/4096/harwaregain/VolPerNm/TorqueBase;
+            torsensor_stTorSensorCof.ulTorqueReg2Pu1 = (ULONG)(((UQWORD)(torsensor_stTorSensorCof.uwBikeTorStep1RealNm - 0) << 24) / 
+                                                (torsensor_stTorSensorCof.uwBikeTorStep1ADC - torsensor_stTorSensorCof.uwTorqueOffset) /TORQUEBASE);
         }
-        tor_pvt_ulCnt = 0;   
+
+        tor_pvt_ulCnt2 = 0;   
     }       
 }
 /***************************************************************
@@ -466,95 +414,72 @@ void torsensor_voOffsetUpdate(void)
 ****************************************************************/
 void torsensor_voTorADC(void) // need to match ADC_StartConversion(ADC1);
 {
+    torsensor_stTorSensorOut.uwTorqueReg = hw_uwADC0[7]; // TorSensor_uwDMAReg;
+#if (TORSENSOR_USEMOL == TORSENSOR_USEDEFAULT)
+    torsensor_stTorSensorOut.uwTorquePu =
+        (((SQWORD)abs((SWORD)(torsensor_stTorSensorOut.uwTorqueReg) - torsensor_stTorSensorCof.uwTorqueOffset)) *
+            torsensor_stTorSensorCof.ulTorqueReg2PuDefault) >>
+        10; // Q14
 
-
-    if (torsensor_stTorSensorOut.blTorqueErrorFlg == TRUE)
+#elif (TORSENSOR_USEMOL == TORSENSOR_USEEE)      
+    if (torsensor_stTorSensorOut.uwTorqueReg <= torsensor_stTorSensorCof.uwTorqueOffset)
     {
         torsensor_stTorSensorOut.uwTorquePu = 0;
-        torsensor_stTorSensorOut.uwTorqueReg = hw_uwADC0[7];
-        if (torsensor_stTorSensorOut.uwTorqueReg < 4000 && torsensor_stTorSensorOut.uwTorqueReg > 10) // output 0mv - 3000mv
-        {
-            torsensor_stTorSensorOut.uwTorqueErrorCnt++;
-            if (torsensor_stTorSensorOut.uwTorqueErrorCnt > 1000)
-            {
-                torsensor_stTorSensorOut.blTorqueErrorFlg = FALSE;
-                torsensor_voTorSensorInit();
-            }
-        }
-        else
-        {
-            torsensor_stTorSensorOut.uwTorqueErrorCnt = 0;
-        }
     }
-    else
+    else if (torsensor_stTorSensorOut.uwTorqueReg <= torsensor_stTorSensorCof.uwBikeTorStep1ADC)
     {
-        torsensor_stTorSensorOut.uwTorqueReg = hw_uwADC0[7]; // TorSensor_uwDMAReg;
-#if (TORSENSOR_USEMOL == TORSENSOR_USEDEFAULT)
-        torsensor_stTorSensorOut.uwTorquePu =
-            (((SQWORD)abs((SWORD)(torsensor_stTorSensorOut.uwTorqueReg) - torsensor_stTorSensorCof.uwTorqueOffset)) *
-             torsensor_stTorSensorCof.ulTorqueReg2PuDefault) >>
-            10; // Q14
-#elif (TORSENSOR_USEMOL == TORSENSOR_USEEE)
-        
-        if (torsensor_stTorSensorOut.uwTorqueReg <= torsensor_stTorSensorCof.uwTorqueOffset)
-        {
-            torsensor_stTorSensorOut.uwTorquePu = 0;
-        }
-        else if (torsensor_stTorSensorOut.uwTorqueReg <= torsensor_stTorSensorCof.uwBikeTorStep1ADC)
-        {
-            torsensor_stTorSensorOut.uwTorquePu = (UWORD)(0 +
-                ((((UQWORD)abs((SWORD)torsensor_stTorSensorOut.uwTorqueReg - torsensor_stTorSensorCof.uwTorqueOffset)) *
-                 torsensor_stTorSensorCof.ulTorqueReg2Pu1) >> 10)); // Q14
-        }
-        else if (torsensor_stTorSensorOut.uwTorqueReg <= torsensor_stTorSensorCof.uwBikeTorStep2ADC)
-        {
-            torsensor_stTorSensorOut.uwTorquePu = (UWORD)(torsensor_stTorSensorCof.uwBikeTorStep1NmPu +
-                ((((UQWORD)abs((SWORD)torsensor_stTorSensorOut.uwTorqueReg - torsensor_stTorSensorCof.uwBikeTorStep1ADC)) *
-                 torsensor_stTorSensorCof.ulTorqueReg2Pu2) >> 10)); // Q14
+        torsensor_stTorSensorOut.uwTorquePu = (UWORD)(0 +
+            ((((UQWORD)abs((SWORD)torsensor_stTorSensorOut.uwTorqueReg - torsensor_stTorSensorCof.uwTorqueOffset)) *
+                torsensor_stTorSensorCof.ulTorqueReg2Pu1) >> 10)); // Q14
+    }
+    else if (torsensor_stTorSensorOut.uwTorqueReg <= torsensor_stTorSensorCof.uwBikeTorStep2ADC)
+    {
+        torsensor_stTorSensorOut.uwTorquePu = (UWORD)(torsensor_stTorSensorCof.uwBikeTorStep1NmPu +
+            ((((UQWORD)abs((SWORD)torsensor_stTorSensorOut.uwTorqueReg - torsensor_stTorSensorCof.uwBikeTorStep1ADC)) *
+                torsensor_stTorSensorCof.ulTorqueReg2Pu2) >> 10)); // Q14
 
-        }
-        else if (torsensor_stTorSensorOut.uwTorqueReg <= torsensor_stTorSensorCof.uwBikeTorStep3ADC)
-        {
-            torsensor_stTorSensorOut.uwTorquePu = (UWORD)(torsensor_stTorSensorCof.uwBikeTorStep2NmPu +
-                ((((UQWORD)abs((SWORD)torsensor_stTorSensorOut.uwTorqueReg - torsensor_stTorSensorCof.uwBikeTorStep2ADC)) *
-                 torsensor_stTorSensorCof.ulTorqueReg2Pu3) >> 10)); // Q14
+    }
+    else if (torsensor_stTorSensorOut.uwTorqueReg <= torsensor_stTorSensorCof.uwBikeTorStep3ADC)
+    {
+        torsensor_stTorSensorOut.uwTorquePu = (UWORD)(torsensor_stTorSensorCof.uwBikeTorStep2NmPu +
+            ((((UQWORD)abs((SWORD)torsensor_stTorSensorOut.uwTorqueReg - torsensor_stTorSensorCof.uwBikeTorStep2ADC)) *
+                torsensor_stTorSensorCof.ulTorqueReg2Pu3) >> 10)); // Q14
 
-        }
-        else if (torsensor_stTorSensorOut.uwTorqueReg <= torsensor_stTorSensorCof.uwBikeTorStep4ADC)
-        {
-            torsensor_stTorSensorOut.uwTorquePu = (UWORD)(torsensor_stTorSensorCof.uwBikeTorStep3NmPu +
-                ((((UQWORD)abs((SWORD)torsensor_stTorSensorOut.uwTorqueReg - torsensor_stTorSensorCof.uwBikeTorStep3ADC)) *
-                 torsensor_stTorSensorCof.ulTorqueReg2Pu4) >> 10)); // Q14
+    }
+    else if (torsensor_stTorSensorOut.uwTorqueReg <= torsensor_stTorSensorCof.uwBikeTorStep4ADC)
+    {
+        torsensor_stTorSensorOut.uwTorquePu = (UWORD)(torsensor_stTorSensorCof.uwBikeTorStep3NmPu +
+            ((((UQWORD)abs((SWORD)torsensor_stTorSensorOut.uwTorqueReg - torsensor_stTorSensorCof.uwBikeTorStep3ADC)) *
+                torsensor_stTorSensorCof.ulTorqueReg2Pu4) >> 10)); // Q14
 
-        }
-        else
-        {
-            torsensor_stTorSensorOut.uwTorquePu = torsensor_stTorSensorCof.uwBikeTorStep4NmPu;
-        }
+    }
+    else
+    {
+        torsensor_stTorSensorOut.uwTorquePu = torsensor_stTorSensorCof.uwBikeTorStep4NmPu;
+    }
 
 #endif
-        mth_voLPFilter((SWORD)torsensor_stTorSensorOut.uwTorquePu, &scm_stTorSensorLpf);
-        torsensor_stTorSensorOut.uwTorqueLPFPu = (UWORD)scm_stTorSensorLpf.slY.sw.hi;
-        torsensor_stTorSensorOut.uwTorquePercent = (UWORD)(((ULONG)torsensor_stTorSensorOut.uwTorqueLPFPu << 14) /
-                (torsensor_stTorSensorCof.uwMaxSensorTorquePu - torsensor_stTorSensorCof.uwMinSensorTorquePu)); // Q15
+    mth_voLPFilter((SWORD)torsensor_stTorSensorOut.uwTorquePu, &torq_pvt_stTorSensorLpf);
+    torsensor_stTorSensorOut.uwTorqueLPFPu = (UWORD)torq_pvt_stTorSensorLpf.slY.sw.hi;
+    torsensor_stTorSensorOut.uwTorquePercent = (UWORD)(((ULONG)torsensor_stTorSensorOut.uwTorqueLPFPu << 14) /
+            (torsensor_stTorSensorCof.uwMaxSensorTorquePu - torsensor_stTorSensorCof.uwMinSensorTorquePu)); // Q15
 
-        if (torsensor_stTorSensorOut.uwTorqueReg > 4000 || torsensor_stTorSensorOut.uwTorqueReg < 10) // output 0mv - 3000mv
-        {
-            torsensor_stTorSensorOut.uwTorqueErrorCnt++;
-            if (torsensor_stTorSensorOut.uwTorqueErrorCnt > 5000)
-            {
-                torsensor_stTorSensorOut.blTorqueErrorFlg = TRUE;
-                torsensor_stTorSensorOut.uwTorquePu = 0;
-                torsensor_stTorSensorOut.uwTorqueErrorCnt = 0;
-                torsensor_stTorSensorOut.uwTorqueLPFPu = 0;
-                cp_stHistoryPara.uwTorSensorAlamTimes++;
-            }
-        }
-        else
+    if (torsensor_stTorSensorOut.uwTorqueReg > 4000 || torsensor_stTorSensorOut.uwTorqueReg < 10) // output 0mv - 3000mv
+    {
+        torsensor_stTorSensorOut.uwTorqueErrorCnt++;
+        if (torsensor_stTorSensorOut.uwTorqueErrorCnt > 5000)
         {
+            torsensor_stTorSensorOut.blTorqueErrorFlg = TRUE;
+            torsensor_stTorSensorOut.uwTorquePu = 0;
             torsensor_stTorSensorOut.uwTorqueErrorCnt = 0;
+            torsensor_stTorSensorOut.uwTorqueLPFPu = 0;
+            cp_stHistoryPara.uwTorSensorAlamTimes++;
         }
     }
+    else
+    {
+        torsensor_stTorSensorOut.uwTorqueErrorCnt = 0;
+    }
 }
 
 /***************************************************************

User project/4.BasicHardwSoftwLayer/1.BasicHardwLayer/Include/hwsetup.h

@@ -24,6 +24,10 @@
 #include "gd32f30x_libopt.h"
 #include "STLmain.h"
 #include "syspar.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
 /************************************************************************
  Compiler Directives (N/A)
 ************************************************************************/
@@ -179,8 +183,10 @@ _HWSETUP_EXT void hw_voIWDGInit(UWORD prer, UWORD rlr);
 /************************************************************************
  Flag Define (N/A)
 ************************************************************************/
+#ifdef __cplusplus
+}
+#endif // __cplusplus
 
-/***********************************************************************/
 #endif
 /************************************************************************
  Copyright (c) 2022 Welling Motor Technology(Shanghai) Co. Ltd.

User project/4.BasicHardwSoftwLayer/2.BasicSoftwLayer/Include/typedefine.h

@@ -20,6 +20,10 @@
 *************************************************************************/
 #ifndef TYPEDEFINE_H
 #define TYPEDEFINE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
 /************************************************************************
  Definitions & Macros (N/A)
 ************************************************************************/
@@ -38,7 +42,7 @@ typedef unsigned long      _ULONG;
 typedef signed long long   _SQWORD;
 typedef unsigned long long _UQWORD;
 
-typedef void               VOID;
+// typedef void               VOID;
 typedef unsigned char      UBYTE; // One byte unsigned
 typedef signed char        SBYTE; // One byte signed
 typedef unsigned short     UWORD; // Two bytes unsigned
@@ -194,6 +198,9 @@ Local Function Call Prototypes (N/A)
 /************************************************************************
  Flag Define (N/A)
 ************************************************************************/
+#ifdef __cplusplus
+}
+#endif // __cplusplus
 #endif
 
 /************************************************************************

unit_test/test_bikespeed.cpp

@@ -1,9 +1,8 @@
 #include "gtest/gtest.h"
 #include <gtest/gtest.h>
 #include <tuple>
-#include "test_user.h"
-#include "hwsetup.h"
 #include "scope.h"
+#include "test_user.h"
 
 class BikeSpeedTest : public testing::Test
 {
@@ -18,7 +17,7 @@ protected:
     }
     virtual void TearDown() override
     {
-
+        bikespeed_voBikeSpeedInit();
     }
 };
 

unit_test/test_cadence.cpp

@@ -1,9 +1,8 @@
 #include "gtest/gtest.h"
 #include <gtest/gtest.h>
 #include <tuple>
-#include "test_user.h"
-#include "hwsetup.h"
 #include "scope.h"
+#include "test_user.h"
 
 class CadenceTest : public testing::Test
 {
@@ -18,7 +17,7 @@ protected:
     }
     virtual void TearDown() override
     {
-
+        cadence_voCadenceInit();
     }
 };
 

unit_test/test_torquesensor.cpp

@@ -0,0 +1,237 @@
+#include "gtest/gtest.h"
+#include <gtest/gtest.h>
+#include <stdint.h>
+#include <tuple>
+#include "scope.h"
+#include "test_user.h"
+
+
+class TorqueSensorTest : public testing::Test
+{
+protected:
+    static void SetUpTestSuite()
+    {
+        torsensor_voTorSensorInit();
+    }
+    virtual void SetUp() override
+    {
+
+    }
+    virtual void TearDown() override
+    {
+        torsensor_voTorSensorInit();
+        torsensor_stTorSensorCof.uwTorqueOffsetConfirmFlg = FALSE;
+        /* Coef Reset */
+        torsensor_stTorSensorCof.uwTorqueOffsetOrign = 0;
+        torsensor_stTorSensorCof.uwTorqueOffsetNow1 = 0;
+        torsensor_stTorSensorCof.uwTorqueOffsetNow2 = 0;
+        torsensor_stTorSensorCof.uwTorqueOffsetNow3 = 0;
+        torsensor_stTorSensorCof.uwTorqueOffsetNow4 = 0;
+    }
+};
+
+class TorqueSensorTest1 : public TorqueSensorTest, public testing::WithParamInterface<double>
+{};
+
+TEST_P(TorqueSensorTest1, TorqCal)
+{
+    /* Coef Cal */
+    torsensor_stTorSensorCof.uwBikeTorStep1ADC = 1310;
+    torsensor_stTorSensorCof.uwBikeTorStep2ADC = 1806;
+    torsensor_stTorSensorCof.uwBikeTorStep3ADC = 2411;
+    torsensor_stTorSensorCof.uwBikeTorStep4ADC = 3009;
+    torsensor_stTorSensorCof.uwBikeTorStep1RealNm = 25;
+    torsensor_stTorSensorCof.uwBikeTorStep2RealNm = 50;
+    torsensor_stTorSensorCof.uwBikeTorStep3RealNm = 75;
+    torsensor_stTorSensorCof.uwBikeTorStep4RealNm = 100;
+    hw_uwADC0[7] = 720;   // 上电零点
+    torsensor_voTorSensorCof();
+
+    /* Torque Input */
+    double torqVol = GetParam();
+    hw_uwADC0[7] = (uint16_t) (torqVol * 4096 / 3.3);
+
+    /* Torque Pu Cal */
+    torsensor_voTorADC();
+
+    double reg2Pu1 = (double)(torsensor_stTorSensorCof.uwBikeTorStep1RealNm - 0) * 16777216 / 
+                    (torsensor_stTorSensorCof.uwBikeTorStep1ADC - torsensor_stTorSensorCof.uwTorqueOffset) /TORQUEBASE; // Q24
+    double reg2Pu2 = (double)(torsensor_stTorSensorCof.uwBikeTorStep2RealNm - torsensor_stTorSensorCof.uwBikeTorStep1RealNm) * 16777216 / 
+                     (torsensor_stTorSensorCof.uwBikeTorStep2ADC - torsensor_stTorSensorCof.uwBikeTorStep1ADC) / TORQUEBASE;  // Q24
+    double reg2Pu3 = (double)(torsensor_stTorSensorCof.uwBikeTorStep3RealNm - torsensor_stTorSensorCof.uwBikeTorStep2RealNm) * 16777216 / 
+                     (torsensor_stTorSensorCof.uwBikeTorStep3ADC - torsensor_stTorSensorCof.uwBikeTorStep2ADC) / TORQUEBASE; // Q24    
+    double reg2Pu4 = (double)(torsensor_stTorSensorCof.uwBikeTorStep4RealNm - torsensor_stTorSensorCof.uwBikeTorStep3RealNm) * 16777216 / 
+                     (torsensor_stTorSensorCof.uwBikeTorStep4ADC - torsensor_stTorSensorCof.uwBikeTorStep3ADC) / TORQUEBASE; // Q24
+
+    double torqPu = 0;
+    if(hw_uwADC0[7] <= torsensor_stTorSensorCof.uwTorqueOffset)     
+    {
+        torqPu = 0;
+    }    
+    else if(hw_uwADC0[7] <= torsensor_stTorSensorCof.uwBikeTorStep1ADC)   
+    {
+        torqPu = (double)(hw_uwADC0[7] - torsensor_stTorSensorCof.uwTorqueOffset)* reg2Pu1 / 1024;
+    }
+    else if(hw_uwADC0[7] <= torsensor_stTorSensorCof.uwBikeTorStep2ADC)   
+    {
+        torqPu = torsensor_stTorSensorCof.uwBikeTorStep1NmPu + (double)(hw_uwADC0[7] - torsensor_stTorSensorCof.uwBikeTorStep1ADC) * reg2Pu2 / 1024;
+    }
+    else if(hw_uwADC0[7] <= torsensor_stTorSensorCof.uwBikeTorStep3ADC)   
+    {
+        torqPu = torsensor_stTorSensorCof.uwBikeTorStep2NmPu + (double)(hw_uwADC0[7] - torsensor_stTorSensorCof.uwBikeTorStep2ADC) * reg2Pu3 / 1024;  
+    }
+    else if(hw_uwADC0[7] <= torsensor_stTorSensorCof.uwBikeTorStep4ADC)   
+    {
+        torqPu = torsensor_stTorSensorCof.uwBikeTorStep3NmPu + (double)(hw_uwADC0[7] - torsensor_stTorSensorCof.uwBikeTorStep3ADC) * reg2Pu4 / 1024;
+    }
+    else
+    {
+        torqPu = torsensor_stTorSensorCof.uwBikeTorStep4NmPu;
+    }
+
+    EXPECT_NEAR(torsensor_stTorSensorOut.uwTorquePu , torqPu, 2);
+
+}
+
+INSTANTIATE_TEST_SUITE_P(DiffTorq, TorqueSensorTest1, ::testing::Values(0, 0.1, 0.8, 1.2, 1.7, 2.5, 3));
+
+class TorqueSensorTest2 : public TorqueSensorTest, public testing::WithParamInterface<::std::tuple<double,double>>
+{};
+TEST_P(TorqueSensorTest2, OffsetUpdate)
+{
+    /* Coef Cal */
+    torsensor_stTorSensorCof.uwBikeTorStep1ADC = 1200;
+    torsensor_stTorSensorCof.uwBikeTorStep2ADC = 1900;
+    torsensor_stTorSensorCof.uwBikeTorStep3ADC = 2600;
+    torsensor_stTorSensorCof.uwBikeTorStep4ADC = 3100;
+    torsensor_stTorSensorCof.uwBikeTorStep1RealNm = 25;
+    torsensor_stTorSensorCof.uwBikeTorStep2RealNm = 50;
+    torsensor_stTorSensorCof.uwBikeTorStep3RealNm = 75;
+    torsensor_stTorSensorCof.uwBikeTorStep4RealNm = 100;
+    hw_uwADC0[7] = 500;    // 上电零点
+    torsensor_voTorSensorCof();
+
+    /* Torque Input */
+    double minReg = get<0>(GetParam());
+    double maxReg = get<1>(GetParam());
+    if(minReg > maxReg)
+    {
+        minReg = maxReg;
+    }
+    if(maxReg > torsensor_stTorSensorCof.uwBikeTorStep1ADC)
+    {
+        maxReg = torsensor_stTorSensorCof.uwBikeTorStep1ADC;
+    }
+
+    int j = 0;
+    for(int i = 0; i < 10000000 ; i++)
+    {
+        if(i % TORQUE_1S_1MSCNT == 0)
+        {
+            j++;
+        }
+
+        if(i < (TORQUE_1S_1MSCNT * j - TORQUE_1S_1MSCNT / 2))
+        {
+            hw_uwADC0[7] = (uint16_t)minReg;
+        }
+        else if(i < TORQUE_1S_1MSCNT * j)
+        {
+            hw_uwADC0[7] = (uint16_t)maxReg;
+        }
+        else 
+        {
+            // do nothing 
+        }
+
+        /* Torque Pu Cal */
+        torsensor_voTorADC();
+        torsensor_voOffsetUpdate();
+
+        //UdpScope::Send(0, torsensor_stTorSensorCof.uwTorqueOffset); 
+        // UdpScope::Send(0, torsensor_stTorSensorCof.uwTorqueOffsetConfirmFlg); 
+        
+    }
+
+    if(maxReg - minReg <= 40)
+    {
+        EXPECT_NEAR(torsensor_stTorSensorCof.uwTorqueOffset, (maxReg + minReg)/2, 2);
+    }
+    else
+    {
+        EXPECT_NEAR(torsensor_stTorSensorCof.uwTorqueOffset, 500, 2);
+    }
+}
+
+INSTANTIATE_TEST_SUITE_P(DiffTorqOffset, TorqueSensorTest2,
+                         ::testing::Combine(::testing::Values(480,495,500), ::testing::Values(510, 530, 600)));
+
+                         
+class TorquePowerOnTest: public testing::Test
+{
+protected:
+    static void SetUpTestSuite()
+    {
+        torsensor_voTorSensorInit();
+    }
+    virtual void SetUp() override
+    {
+
+    }
+    virtual void TearDown() override
+    {
+        torsensor_voTorSensorInit();
+        torsensor_stTorSensorCof.uwTorqueOffsetConfirmFlg = FALSE;
+    }
+};
+
+class TorquePowerOnTest1 : public TorquePowerOnTest, public testing::WithParamInterface<double>
+{};
+
+int i = 0;
+double offsetLast[4] = {0,0,0,0};
+TEST_P(TorquePowerOnTest1, OffsetUpdate)
+{
+
+    /* Coef Cal */
+    torsensor_stTorSensorCof.uwBikeTorStep1ADC = 1310;
+    torsensor_stTorSensorCof.uwBikeTorStep2ADC = 1806;
+    torsensor_stTorSensorCof.uwBikeTorStep3ADC = 2411;
+    torsensor_stTorSensorCof.uwBikeTorStep4ADC = 3009;
+    torsensor_stTorSensorCof.uwBikeTorStep1RealNm = 25;
+    torsensor_stTorSensorCof.uwBikeTorStep2RealNm = 50;
+    torsensor_stTorSensorCof.uwBikeTorStep3RealNm = 75;
+    torsensor_stTorSensorCof.uwBikeTorStep4RealNm = 100;
+    hw_uwADC0[7] = (uint16_t)GetParam();   // 上电零点
+    torsensor_voTorSensorCof();
+
+    i++;
+    if(i > 1)
+    {
+        double offsetAvg = 0;
+        if(offsetLast[0] == 0)
+        {
+            offsetAvg = torsensor_stTorSensorCof.uwTorqueOffsetOrign;
+        }  
+        else 
+        {
+            offsetAvg = (offsetLast[0] + offsetLast[1] + offsetLast[2] + offsetLast[3]) / 4;
+        }
+
+        if(abs((double)hw_uwADC0[7] - offsetAvg) > 200)
+        {
+            EXPECT_NEAR(torsensor_stTorSensorCof.uwTorqueOffset, offsetAvg, 2);
+        }
+        else 
+        {
+            offsetLast[0] = offsetLast[1];
+            offsetLast[1] = offsetLast[2];
+            offsetLast[2] = offsetLast[3];
+            offsetLast[3] = torsensor_stTorSensorCof.uwTorqueOffset;
+
+            EXPECT_NEAR(torsensor_stTorSensorCof.uwTorqueOffset, hw_uwADC0[7], 2);
+        }
+    }
+}
+
+INSTANTIATE_TEST_SUITE_P(DiffTorqOffset, TorquePowerOnTest1, ::testing::Values(500, 536, 600, 810, 630, 680, 460, 1000, 350, 2000, 520));

unit_test/test_user.c

@@ -5,6 +5,9 @@ int testCh2CapValue[2];
 int testCh3CapValue[2];
 int testGpioBValue[2];
 
+UWORD hw_uwADC0[ADC0_DMA_NUM];
+MC_UpperPCInfo_Struct_t MC_UpcInfo;
+
 int timer_interrupt_flag_get(int timer_periph, int interrupt)
 {
     return testTimerIntFlg[timer_periph][interrupt];

unit_test/test_user.h

@@ -1,7 +1,10 @@
 #include "Cadence.h"
 #include "bikespeed.h"
+#include "torquesensor.h"
 
-
+#include "canAppl.h"
+#include "hwsetup.h"
+#include "typedefine.h"
 
 #ifndef _TEST_USER_H_
 #define _TEST_USER_H_
@@ -25,6 +28,7 @@ extern "C" {
 
 #define abs(x)    ((x) >= 0 ? (x) : (-(x)))
 
+
 extern int testTimerIntFlg[2][4];
 extern int testCh2CapValue[2];
 extern int testCh3CapValue[2];

xmake.lua

@@ -7,8 +7,8 @@ target("unittest")
     set_languages("c++20")
 
     add_files("unit_test/*.cpp","unit_test/tools/*.cpp","unit_test/tools/*.c", "unit_test/*.c")
-    add_files("User project/3.BasicFunction/Source/Cadence.c", "User project/4.BasicHardwSoftwLayer/2.BasicSoftwLayer/Source/CodePara.c")
-    add_files("User project/3.BasicFunction/Source/bikespeed.c")
+    add_files("User project/4.BasicHardwSoftwLayer/2.BasicSoftwLayer/Source/CodePara.c", "User project/4.BasicHardwSoftwLayer/2.BasicSoftwLayer/Source/mathtool.c")
+    add_files("User project/3.BasicFunction/Source/Cadence.c", "User project/3.BasicFunction/Source/bikespeed.c", "User project/3.BasicFunction/Source/torquesensor.c")
 
     -- add_includedirs("Std project/CMSIS")
     -- add_includedirs("Std project/CMSIS/GD/GD32F30x/Inc_GD")