1、变速器通信超时时间设置3s；

2、增加根据SOC计算最大电流和最大车速系数，指拨和助力模式根据SOC限制最大电流和最大车速；
3、转把启动偏移电压由0.1V调整为1.25V；
4、欠压保护值高4位改用欠压保护方式和保护延时设置，bit15为0-根据电压保护，bit15为1-根据SOC保护，bit14~bit12用于设置保护延时时间，保护延时=5+设置值*10，同时修改欠压保护处理；
5、修改开机电量初始化时间；
6、运行信息电功率采用额定功率和高5位的分频系数进行计算，计算方法如下：
   发送功率 = 母线电流 / 最大电流 * (额定功率 * (分频系数 + 1) / 32)
7、BMS通信状态检测超时时间设置5s
8、修改传动比计算方法；
9、转把速度模式采用新计算的传动比（目前测试小飞车速上不去，待查）

MDK-ARM/QD007A_CTL_APP.uvprojx

@@ -362,7 +362,7 @@
             <useXO>0</useXO>
             <VariousControls>
               <MiscControls></MiscControls>
-              <Define>USE_HAL_DRIVER,STM32F103xB</Define>
+              <Define>USE_HAL_DRIVER,STM32F103xB,VOLANS_36V</Define>
               <Undefine></Undefine>
               <IncludePath>../Core/Inc;../Drivers/STM32F1xx_HAL_Driver/Inc;../Drivers/STM32F1xx_HAL_Driver/Inc/Legacy;../Drivers/CMSIS/Device/ST/STM32F1xx/Include;../Drivers/CMSIS/Include;..\User\Inc;..\SEGGER_RTT\Inc;..\SelfTestUser\Inc</IncludePath>
             </VariousControls>

SelfTestUser/src_middlewares/stm32fxx_STUaddressing.c

@@ -3,8 +3,8 @@
 #include "stm32fxx_STUaddressing.h"
 
 
-volatile uint32_t testCell_1    __attribute__((at(0x20000600)));  //必须在Zero段,否则编译会提示内存冲突
-volatile uint32_t testCell_2    __attribute__((at(0x20000610)));
+volatile uint32_t testCell_1    __attribute__((at(0x20000800)));  //必须在Zero段,否则编译会提示内存冲突
+volatile uint32_t testCell_2    __attribute__((at(0x20000810)));
 
 uint8_t STU_AddressingTest(void)
 {

User/Inc/var.h

@@ -484,13 +484,13 @@ typedef struct
 //传动比计算参数
 typedef struct
 {
-  uint16_t Ratio_Per;                           //实时传动比，车速(km/h) / 电机转速(rpm)* 102400，车速 = 电机转速 / 4.55 * 前牙盘 / 后牙盘 * 轮胎周长 * 60 / 1000
-	uint16_t Ratio_Avg;                           //传动比平均值
-	uint16_t Ratio_Max;                           //传动比最大值
-	uint16_t Ratio_Min;                           //传动比最小值
-	uint16_t Ratio_Result;                        //传动比使用值
-	TrueOrFalse_Flag_Struct_t Ratio_ShiftFlag;    //挡位切换完成标志
-	uint16_t Ratio_Array[50];                     //传动比缓存
+  uint16_t RatioPer;                           //实时传动比，车速(km/h) / 电机转速(rpm)* 102400，车速 = 电机转速 / 4.55 * 前牙盘 / 后牙盘 * 轮胎周长 * 60 / 1000
+	uint16_t RatioFlt;                           //传动比滤波值
+	int32_t RatioFltSum;
+	uint16_t TargetAcc;                          //目标值递增阶梯
+	uint16_t TargetDec;                          //目标值递减阶梯
+	uint16_t RatioDefault;                       //传动比默認值
+	uint16_t RatioResult;                        //传动比输出
 }Bike_RatioCal_Struct_t;
 
 //硬件版本定义表

User/Src/MC_FOC_Driver.c

@@ -45,12 +45,12 @@ void FOC_Model(int16_t Ref, int16_t MotorSpeed, uint16_t SVM_Angle)	  //
 	IdFdbFlt += (((int32_t)(Stat_Curr_q_d.qI_Component2 << 10)) - IdFdbFlt)>>10;   // KFlt = 2ms
 	IdFdb = IdFdbFlt >> 10;
 
-	if((MC_HallSensorData.BackwardFlag==TRUE)&&(MC_CalParam.AssistRunMode == MC_AssistRunMode_GAS))
+	if((MC_HallSensorData.BackwardFlag == TRUE) && (MC_CalParam.AssistRunMode == MC_AssistRunMode_GAS))
 	{
-		if( ADC1_Result[ADC1_RANK_VIN] < 2284) //41000mV  17.951  2284
+		if( ADC1_Result[ADC1_RANK_VIN] < 2284) //41000mV 2284
 		{
 			IqFluxLessRef = Ref;
-			if(IdFluxLessRef<(-4))
+			if(IdFluxLessRef < (-4))
 			{
 				IdFluxLessRef += 4;
 			}
@@ -58,10 +58,10 @@ void FOC_Model(int16_t Ref, int16_t MotorSpeed, uint16_t SVM_Angle)	  //
 		}
 		else if( ADC1_Result[ADC1_RANK_VIN] < 2494 ) //44769mV 2494
 		{
-			FOC_IqLim = 1050 - (ADC1_Result[ADC1_RANK_VIN] - 2284)*5;
-			IqFluxLessRef = Ref<FOC_IqLim ? Ref : FOC_IqLim;
+			FOC_IqLim = 1050 - (ADC1_Result[ADC1_RANK_VIN] - 2284) * 5;
+			IqFluxLessRef = Ref < FOC_IqLim ? Ref : FOC_IqLim;
 			IdFluxLessRef -= 2;
-			if(IdFluxLessRef<-420) IdFluxLessRef = -420;
+			if(IdFluxLessRef < -420) IdFluxLessRef = -420;
 		}
 		else
 		{
@@ -72,7 +72,7 @@ void FOC_Model(int16_t Ref, int16_t MotorSpeed, uint16_t SVM_Angle)	  //
 	else
 	{
 			IqFluxLessRef = Ref;
-			if(IdFluxLessRef<(-4))
+			if(IdFluxLessRef < (-4))
 			{
 				IdFluxLessRef += 4;
 			}

User/Src/enviolo_can.c

@@ -165,7 +165,7 @@ void GearBox_Loop(void)
 	//变速器在线检测
 	if(GearBox_OnlineFlag.IsOK_Flag == TRUE)
 	{
-    if((HAL_GetTick() - GearBox_OnlineFlag.OK_TrigTime) > 1000) //变速器超时1s认为离线
+    if((HAL_GetTick() - GearBox_OnlineFlag.OK_TrigTime) > 3000) //变速器超时1s认为离线
 		{
 			GearBox_OnlineFlag.IsOK_Flag = FALSE;
 		}
@@ -259,7 +259,8 @@ void GearBox_Loop(void)
 					EnvioloControlParams.CadenceMode_Data = GearBox_OBC_SetParams.CadenceMin;
 				else if(GearBox_OBC_SetMode.Value > GearBox_OBC_SetParams.CadenceMax)
 					EnvioloControlParams.CadenceMode_Data = GearBox_OBC_SetParams.CadenceMax;
-				EnvioloControlParams.CadenceMode_Data = GearBox_OBC_SetMode.Value;
+				else
+				    EnvioloControlParams.CadenceMode_Data = GearBox_OBC_SetMode.Value;
 				EnvioloControlParams.RatioMode_Data = 0;
 			}
 			//更新变速器运行信息，高5位表示变速器状态，低5位表示变速器当前档位

User/Src/hall_sensor.c

@@ -161,7 +161,7 @@ void HallSensor_Process(void)
 		MC_HallSensorData.Delta_Angle = 0;
 		MC_HallSensorData.SVM_Angle = HallAngle_Data[MC_HallSensorStatus.HallGropuStatus] + (ANGLE_60D >> 1);
 		MC_HallSensorData.PWM_NumCnt = 0xFFFF;
-		if(++backwardcount>5) 
+		if(++backwardcount > 5) 
 		{
 			backwardcount = 6;
 			MC_HallSensorData.BackwardFlag = TRUE;

User/Src/motor_control.c

@@ -129,6 +129,40 @@ uint16_t MC_Cal_K_ByVoltage(uint16_t Voltage, uint16_t DesignVol, uint16_t K_Vol
 	return(Result);
 }
 
+//随SOC计算限流衰减系数
+uint16_t MC_LimitCurrent_Cal_K_BySOC(uint16_t SOC)
+{
+  uint16_t Limit_K_BySOC = 1024;
+	if(SOC <= 2)
+		Limit_K_BySOC = 256;
+	else if(SOC <= 6)
+		Limit_K_BySOC = 256 + (SOC - 2) * 64;
+	else if(SOC <= 22)
+	  Limit_K_BySOC = 512 + (SOC - 6) * 24;
+	else if(SOC <= 30)
+		Limit_K_BySOC = 896 + (SOC - 22) * 16;
+	else
+		Limit_K_BySOC = 1024;
+	return Limit_K_BySOC;
+}
+
+//随SOC计算限速衰减系数
+uint16_t MC_LimitSpeed_Cal_K_BySOC(uint16_t SOC)
+{
+  uint16_t Limit_K_BySOC = 1024;
+	if(SOC <= 2)
+		Limit_K_BySOC = 512;
+	else if(SOC <= 6)
+		Limit_K_BySOC = 512 + (SOC - 2) * 32;
+	else if(SOC <= 22)
+	  Limit_K_BySOC = 640 + (SOC - 6) * 20;
+	else if(SOC <= 30)
+		Limit_K_BySOC = 960 + (SOC - 22) * 8;
+	else
+		Limit_K_BySOC = 1024;
+	return Limit_K_BySOC;
+}
+
 //随温度计算助力衰减系数
 uint16_t MC_Cal_K_ByTemperature(uint16_t CoilTemp, uint16_t AlarmTempTH)
 {
@@ -158,12 +192,12 @@ MC_AssistRunMode_Struct_t MC_JudgeAsistRunMode_Process(MC_GasMode_Struct_t GasMo
 	  if((GearSt != MC_GearSt_OFF) && (StopFlag == FALSE) && (HAL_GetTick()>3000) )
 		{
 		  //进入指拨模式
-			if((GasSensorData > 100) && (GasMode_Param.Mode != (uint8_t)MC_SUPPORT_DISABLE)) 
+			if((GasSensorData > 200) && (GasMode_Param.Mode != (uint8_t)MC_SUPPORT_DISABLE)) //转把启动电压 = 零点电压 + (TH / 4096 * 3.3) / 10 * 15.6，5V转把0.3V启动
 			{
 				MC_AssistRunMode_Result = MC_AssistRunMode_GAS;
 			}
 			//退出指拨模式
-			else if(GasSensorData < 50)  
+			else if(GasSensorData < 100)  
 			{
 				//进入推行模式
 				if(GearSt == MC_GearSt_WALK)
@@ -297,16 +331,21 @@ MC_CalParam_Struct_t MC_AssistRunMode_GasSpeed_Process(MC_GasMode_Struct_t GasMo
 
 	/*电机最高速度,上位机配置参数*/
 	SpeedMax = MC_MotorParam.Rate_Speed;
-	Tmp = SensorData-50;  //指拨100启动，减去50能控低速
+	Tmp = SensorData - 100;  //指拨200启动，减去100能控低速
 	Tmp = Tmp > 2048 ? 2048 : Tmp; 
-	Tmp = (Tmp*Tmp)/2048;   //指拨值改为抛物线，低速控制行程变大
+	Tmp = (Tmp * Tmp) / 2048;   //指拨值改为抛物线，低速控制行程变大
 	/*电机转速设定，根据指拨大小、车轮限速值和速比，换算*/
 	if(MC_GasMode_Param.Mode_bit.SpeedLimit <= 5)
-	  SpeedLimit = MC_ConfigParam1.SpeedLimit + (int8_t)MC_ConfigParam2.SpeedLimitAdj + MC_GasMode_Param.Mode_bit.SpeedLimit + 0x1F - (0xAA >> 3);
+	  SpeedLimit = ((MC_ConfigParam1.SpeedLimit + (int8_t)MC_ConfigParam2.SpeedLimitAdj + MC_GasMode_Param.Mode_bit.SpeedLimit + 0x1F - (0xAA >> 3)) * MC_LimitSpeed_Cal_K_BySOC(MC_RunInfo.SOC)) >> 10;
 	else
-		SpeedLimit = MC_ConfigParam1.SpeedLimit + (int8_t)MC_ConfigParam2.SpeedLimitAdj + MC_GasMode_Param.Mode_bit.SpeedLimit - (0xAA >> 3);
-	SpeedSet = Tmp * (SpeedLimit * SpdProportion) / 10  >> 11; //(Tmp >> 11) * cd_Speedlimit * ( SpdProportion / 10)
-	
+	  SpeedLimit = ((MC_ConfigParam1.SpeedLimit + (int8_t)MC_ConfigParam2.SpeedLimitAdj + MC_GasMode_Param.Mode_bit.SpeedLimit - (0xAA >> 3)) * MC_LimitSpeed_Cal_K_BySOC(MC_RunInfo.SOC)) >> 10;
+	//根据SOC限制最大车速
+	#if 0 //旧版传动比计算
+	SpeedSet = Tmp * (SpeedLimit * SpdProportion) / 10  >> 11; //(Tmp >> 11) * cd_Speedlimit * ( SpdProportion / 10)  	
+	#else //新版传动比计算
+  SpeedSet = Tmp * SpeedLimit * 50 / Bike_RatioCalParam.RatioResult;
+	#endif
+
 	//超过限速值，设定电机转速为0
 	if(wheelSpeed > (SpeedLimit * 10 + 20))
 	{
@@ -398,7 +437,7 @@ MC_CalParam_Struct_t MC_AssistRunMode_GasSpeed_Process(MC_GasMode_Struct_t GasMo
 	PID_MotorSpd.hLower_Limit_Output = -100;
 	PID_MotorSpd.hUpper_Limit_Output = 1050;	
 	/*限制母线电流*/
-	SpdMotorByIdc = PID_Regulator((MC_ConfigParam1.CurrentLimit * 1000) >> 7, MC_RunInfo.BusCurrent >> 7, &PID_ConstantPower);
+	SpdMotorByIdc = PID_Regulator((MC_ConfigParam1.CurrentLimit * 1000 * MC_LimitCurrent_Cal_K_BySOC(MC_RunInfo.SOC)) >> 17, MC_RunInfo.BusCurrent >> 7, &PID_ConstantPower);
 	
 	#if 1
 	static uint16_t K_ByVoltage_Set_Old = 1024;
@@ -425,8 +464,6 @@ MC_CalParam_Struct_t MC_AssistRunMode_GasSpeed_Process(MC_GasMode_Struct_t GasMo
 	
 	#endif
 	
-
-	
 	Ref_Speed_Temp = ((int32_t)TorQueBySpd * K_ByVoltage_Result) >> 10;
 	Ref_Speed_Temp = ((int32_t)Ref_Speed_Temp * K_ByTemperature_Result) >> 10;
 	
@@ -447,7 +484,7 @@ MC_CalParam_Struct_t MC_AssistRunMode_GasSpeed_Process(MC_GasMode_Struct_t GasMo
 		else ExitGasModeFlag = RESET;
 	}
 	
-	if(Ref_Speed_Temp_End < -200) Ref_Speed_Temp_End=-200;
+	if(Ref_Speed_Temp_End < -200) Ref_Speed_Temp_End = -200;
 	//速度环控制量为0时停机，防止电机出现异响
 	if(SpeedSetReal == 0)
 	{
@@ -459,7 +496,7 @@ MC_CalParam_Struct_t MC_AssistRunMode_GasSpeed_Process(MC_GasMode_Struct_t GasMo
 		MC_MotorStar(&MC_StarFlag);
 	}
 	
-	p_MC_CalParam.Ref_Speed = (int16_t)((Ref_Speed_Temp_End+SpdMotorByIdc)>>1);
+	p_MC_CalParam.Ref_Speed = (int16_t)((Ref_Speed_Temp_End + SpdMotorByIdc) >> 1);
 	p_MC_CalParam.Foc_Flag = SET;
 	p_MC_CalParam.AssistRunMode = MC_AssistRunMode_GAS;
 	
@@ -595,19 +632,19 @@ MC_CalParam_Struct_t MC_AssistRunMode_GasTorque_Process(MC_GasMode_Struct_t GasM
 	
 	//限速值设定
 	static uint16_t speedLimitStart = 250, speedLimitEnd = 272, slewRate = 52;
-	if((MC_ConfigParam2.SpeedLimitStartAdj > 50) || (MC_ConfigParam2.SpeedLimitStartAdj < -50)) MC_ConfigParam2.SpeedLimitStartAdj=0;
-	if((MC_ConfigParam2.SpeedLimitEndAdj > 50) || (MC_ConfigParam2.SpeedLimitEndAdj < -50)) MC_ConfigParam2.SpeedLimitEndAdj=0;
+	if((MC_ConfigParam2.SpeedLimitStartAdj > 50) || (MC_ConfigParam2.SpeedLimitStartAdj < -50)) MC_ConfigParam2.SpeedLimitStartAdj = 0;
+	if((MC_ConfigParam2.SpeedLimitEndAdj > 50) || (MC_ConfigParam2.SpeedLimitEndAdj < -50)) MC_ConfigParam2.SpeedLimitEndAdj = 0;
 		
 	if(MC_GasMode_Param.Mode_bit.SpeedLimit <= 5)
 	{
-	  speedLimitStart = (MC_ConfigParam1.SpeedLimit + (int8_t)MC_ConfigParam2.SpeedLimitAdj + GasMode_Param.Mode_bit.SpeedLimit + 0x1F - (0xAA >> 3)) * 10 + MC_ConfigParam2.SpeedLimitStartAdj;
-	  speedLimitEnd = (MC_ConfigParam1.SpeedLimit + (int8_t)MC_ConfigParam2.SpeedLimitAdj + GasMode_Param.Mode_bit.SpeedLimit + 0x1F - (0xAA >> 3)) * 10 + MC_ConfigParam2.SpeedLimitEndAdj + 22;
+	  speedLimitStart = (((MC_ConfigParam1.SpeedLimit + (int8_t)MC_ConfigParam2.SpeedLimitAdj + GasMode_Param.Mode_bit.SpeedLimit + 0x1F - (0xAA >> 3) - 2) * 10 + MC_ConfigParam2.SpeedLimitStartAdj) * MC_LimitSpeed_Cal_K_BySOC(MC_RunInfo.SOC)) >> 10;
+	  speedLimitEnd = (((MC_ConfigParam1.SpeedLimit + (int8_t)MC_ConfigParam2.SpeedLimitAdj + GasMode_Param.Mode_bit.SpeedLimit + 0x1F - (0xAA >> 3)) * 10 + MC_ConfigParam2.SpeedLimitEndAdj + 22) * MC_LimitSpeed_Cal_K_BySOC(MC_RunInfo.SOC)) >> 10;
 	  slewRate = 1024 / (speedLimitEnd - speedLimitStart - 3);		
 	}
 	else
 	{
-	  speedLimitStart = (MC_ConfigParam1.SpeedLimit + (int8_t)MC_ConfigParam2.SpeedLimitAdj + GasMode_Param.Mode_bit.SpeedLimit - (0xAA >> 3)) * 10 + MC_ConfigParam2.SpeedLimitStartAdj;
-	  speedLimitEnd = (MC_ConfigParam1.SpeedLimit + (int8_t)MC_ConfigParam2.SpeedLimitAdj + GasMode_Param.Mode_bit.SpeedLimit - (0xAA >> 3)) * 10 + MC_ConfigParam2.SpeedLimitEndAdj + 22;
+	  speedLimitStart = (((MC_ConfigParam1.SpeedLimit + (int8_t)MC_ConfigParam2.SpeedLimitAdj + GasMode_Param.Mode_bit.SpeedLimit - (0xAA >> 3) - 2) * 10 + MC_ConfigParam2.SpeedLimitStartAdj) * MC_LimitSpeed_Cal_K_BySOC(MC_RunInfo.SOC)) >> 10;
+	  speedLimitEnd = (((MC_ConfigParam1.SpeedLimit + (int8_t)MC_ConfigParam2.SpeedLimitAdj + GasMode_Param.Mode_bit.SpeedLimit - (0xAA >> 3)) * 10 + MC_ConfigParam2.SpeedLimitEndAdj + 22) * MC_LimitSpeed_Cal_K_BySOC(MC_RunInfo.SOC)) >> 10;
 	  slewRate = 1024 / (speedLimitEnd - speedLimitStart - 3);		
 	}	
 			
@@ -703,13 +740,14 @@ MC_CalParam_Struct_t MC_AssistRunMode_GasTorque_Process(MC_GasMode_Struct_t GasM
 	uint16_t K_ByTemperature_Result = 1024;
 	#endif
 	
-  //限流计算
-	IqRefByInPower = PID_Regulator(CurrentLimitPresent * (MC_RunInfo.SOC <= 5 ? 5 : (MC_RunInfo.SOC >= 10 ? 10 : MC_RunInfo.SOC)) / 1000, (MC_RunInfo.BusCurrent >> 7), &PID_IMax);
-	
+    //根据SOC计算限流
+	IqRefByInPower = PID_Regulator((CurrentLimitPresent * MC_LimitCurrent_Cal_K_BySOC(MC_RunInfo.SOC) / 100) >> 10, (MC_RunInfo.BusCurrent >> 7), &PID_IMax);
+
 	Torque_Ref_Temp = ((int32_t)MC_TorqueProcess_Param.TorqueRefEnd * K_ByVoltage_Result) >> 10;
 	Torque_Ref_Temp = (Torque_Ref_Temp * K_ByTemperature_Result) >> 10;
 	Torque_Ref_Temp = (Torque_Ref_Temp + IqRefByInPower) >> 1;
 	
+	//Iq输出
 	p_MC_CalParam.Ref_Torque = (int16_t)Torque_Ref_Temp;
 	p_MC_CalParam.Foc_Flag = SET;
 	p_MC_CalParam.AssistRunMode = MC_AssistRunMode_GAS;
@@ -774,7 +812,8 @@ MC_CalParam_Struct_t MC_AssistRunMode_Walk_Process(MC_WorkMode_Struct_t p_MC_Wor
 		{
 		  MC_WalkProcess_Param.MotorSpeedSetBigin = WalkMode_MotorSpeedSet << 5;
 		}
-		SpdMotorByIdc = PID_Regulator((MC_ConfigParam1.CurrentLimit * 500) >> 7, MC_RunInfo.BusCurrent >> 7, &PID_ConstantPower); // 母线电流闭环
+		//根据SOC计算限流
+	  SpdMotorByIdc = PID_Regulator((MC_ConfigParam1.CurrentLimit * 500 * MC_LimitCurrent_Cal_K_BySOC(MC_RunInfo.SOC)) >> 17, MC_RunInfo.BusCurrent >> 7, &PID_ConstantPower); // 母线电流闭环
 	}
 	
 	//速度环
@@ -1183,8 +1222,8 @@ MC_CalParam_Struct_t MC_AssistRunMode_Torque_Process(uint16_t SenorData, MC_Gear
 		static uint16_t speedLimitStart = 250, speedLimitEnd = 272, slewRate = 52;
 		if((MC_ConfigParam2.SpeedLimitStartAdj > 50) || (MC_ConfigParam2.SpeedLimitStartAdj < -50)) MC_ConfigParam2.SpeedLimitStartAdj = 0;
 		if((MC_ConfigParam2.SpeedLimitEndAdj > 50) || (MC_ConfigParam2.SpeedLimitEndAdj < -50)) MC_ConfigParam2.SpeedLimitEndAdj = 0;		
-		speedLimitStart = (MC_ConfigParam1.SpeedLimit + (int8_t)MC_ConfigParam2.SpeedLimitAdj) * 10 + MC_ConfigParam2.SpeedLimitStartAdj;
-		speedLimitEnd   = (MC_ConfigParam1.SpeedLimit + (int8_t)MC_ConfigParam2.SpeedLimitAdj) * 10 + MC_ConfigParam2.SpeedLimitEndAdj + 22;
+		speedLimitStart = (((MC_ConfigParam1.SpeedLimit + (int8_t)MC_ConfigParam2.SpeedLimitAdj) * 10 + MC_ConfigParam2.SpeedLimitStartAdj) * MC_LimitSpeed_Cal_K_BySOC(MC_RunInfo.SOC)) >> 10;
+		speedLimitEnd   = (((MC_ConfigParam1.SpeedLimit + (int8_t)MC_ConfigParam2.SpeedLimitAdj) * 10 + MC_ConfigParam2.SpeedLimitEndAdj + 22) * MC_LimitSpeed_Cal_K_BySOC(MC_RunInfo.SOC)) >> 10;
 		slewRate        = 1024 / (speedLimitEnd - speedLimitStart - 3);		
 		//随车速调节助力比
 		Torque_Temp = (uint16_t)((uint32_t)(Torque_Temp * Function_Linear_3Stage(speedLimitStart, 0, speedLimitStart, slewRate, MC_SpeedSensorData.Speed_Data)) >> 10);
@@ -1327,13 +1366,14 @@ MC_CalParam_Struct_t MC_AssistRunMode_Torque_Process(uint16_t SenorData, MC_Gear
 	uint16_t K_ByTemperature_Result = 1024;
 	#endif
 	
-  //限流计算
-	IqRefByInPower = PID_Regulator(CurrentLimitPresent * (MC_RunInfo.SOC <= 5 ? 5 : (MC_RunInfo.SOC >= 10 ? 10 : MC_RunInfo.SOC)) / 1000, (MC_RunInfo.BusCurrent >> 7), &PID_IMax);
+    //根据SOC计算限流
+	IqRefByInPower = PID_Regulator((CurrentLimitPresent * MC_LimitCurrent_Cal_K_BySOC(MC_RunInfo.SOC) / 100) >> 10, (MC_RunInfo.BusCurrent >> 7), &PID_IMax);
 	
 	Torque_Ref_Temp = ((int32_t)MC_TorqueProcess_Param.TorqueRefEnd * K_ByVoltage_Result) >> 10;
 	Torque_Ref_Temp = (Torque_Ref_Temp * K_ByTemperature_Result) >> 10;
 	Torque_Ref_Temp = (Torque_Ref_Temp + IqRefByInPower) >> 1;
 	
+	//Iq输出
 	p_MC_CalParam.Ref_Torque = (int16_t)Torque_Ref_Temp;
 	p_MC_CalParam.Foc_Flag = SET;
 	p_MC_CalParam.AssistRunMode = MC_AssistRunMode_TORQUE;

User/Src/protect_check.c

@@ -17,41 +17,17 @@ void MC_Protect_UnderVoltage_Process(TrueOrFalse_Flag_Struct_t IsBMS_ComOK, uint
 	static uint32_t uvFaultTimeCnt = 0;
 	uint16_t UV_Voltage = 0;
 	
-	//根据额定电压更新保护阈值
-	switch(DesignVoltage)
-	{
-		case 24:
-		{
-			UV_Voltage = UV_TH * 7;//低压保护时，电芯电压为3100mV
-			break;
-		}
-		case 36:
-		{
-			UV_Voltage = UV_TH * 10;//低压保护时，电芯电压为3100mV
-			break;
-		}
-		case 48:
-		{
-			UV_Voltage = UV_TH * 13;//低压保护时，电芯电压为3100mV
-			break;
-		}
-		default:
-		{
-			UV_Voltage = BusVoltage;
-			break;
-		}
-	}
-	
-	if(IsBMS_ComOK == TRUE)//电池通讯正常，根据BMS的SOC作为低压保护
+	//UV_TH Bit15 = 1，按照SOC进行低电量保护
+	if((UV_TH >> 15) == 1)
 	{
 	  if(p_MC_ErrorCode->ERROR_Bit.Protect_UnderVoltage == 0)
 		{
 			//低压保护判断
-			if((SOC >= 1) && (BusVoltage >= UV_Voltage))
+			if(SOC >= 1)
 			{
 				uvTimeCnt = HAL_GetTick();
 			}
-			if((HAL_GetTick() - uvTimeCnt) > 5000)
+			if((HAL_GetTick() - uvTimeCnt) > ((5 + ((UV_TH >> 12) & 0x07) * 10) * 1000))
 			{
 				p_MC_ErrorCode->ERROR_Bit.Protect_UnderVoltage = 1;
 				//记录故障日志
@@ -68,7 +44,7 @@ void MC_Protect_UnderVoltage_Process(TrueOrFalse_Flag_Struct_t IsBMS_ComOK, uint
 		else
 		{
 			//低压保护恢复
-			if((SOC < 1) || (BusVoltage < (UV_Voltage + 1000)))
+			if(SOC < 5)
 			{
 				uvFaultTimeCnt = HAL_GetTick();
 			}	
@@ -77,9 +53,34 @@ void MC_Protect_UnderVoltage_Process(TrueOrFalse_Flag_Struct_t IsBMS_ComOK, uint
 				p_MC_ErrorCode->ERROR_Bit.Protect_UnderVoltage = 0;
 			}
 		}
-	}
+	}	
+	//按照电压保护
 	else
 	{
+	  //根据额定电压更新保护阈值
+		switch(DesignVoltage)
+		{
+			case 24:
+			{
+				UV_Voltage = (UV_TH & 0x0FFF) * 7;//低压保护时，电芯电压为3000mV
+				break;
+			}
+			case 36:
+			{
+				UV_Voltage = (UV_TH & 0x0FFF) * 10;//低压保护时，电芯电压为3000mV
+				break;
+			}
+			case 48:
+			{
+				UV_Voltage = (UV_TH & 0x0FFF) * 13;//低压保护时，电芯电压为3000mV
+				break;
+			}
+			default:
+			{
+				UV_Voltage = BusVoltage;
+				break;
+			}
+		}
 		if(p_MC_ErrorCode->ERROR_Bit.Protect_UnderVoltage == 0)
 		{
 			//低压保护判断
@@ -87,7 +88,7 @@ void MC_Protect_UnderVoltage_Process(TrueOrFalse_Flag_Struct_t IsBMS_ComOK, uint
 			{
 				uvTimeCnt = HAL_GetTick();
 			}
-			if((HAL_GetTick() - uvTimeCnt) > 5000)
+			if((HAL_GetTick() - uvTimeCnt) > ((5 + ((UV_TH >> 12) & 0x07) * 10) * 1000))
 			{
 				p_MC_ErrorCode->ERROR_Bit.Protect_UnderVoltage = 1;
 				//记录故障日志
@@ -451,7 +452,7 @@ void MC_Protect_Check_Process(void)
 {
 	//低压保护检测
   MC_Protect_UnderVoltage_Process(IsComOK_BMS.IsOK_Flag, MC_RunInfo.SOC, ((IsComOK_BMS.IsOK_Flag == TRUE) ? BMS_RunInfo.Voltage : MC_RunInfo.BusVoltage), 
-	                                MC_MotorParam.Rate_Voltage, ((MC_ConfigParam1.UV_Protect_TH == 0) ? 3000 : MC_ConfigParam1.UV_Protect_TH), 
+	                                MC_MotorParam.Rate_Voltage, (((MC_ConfigParam1.UV_Protect_TH & 0x0FFF) == 0) ? 3000 : MC_ConfigParam1.UV_Protect_TH), 
 	                                &MC_ErrorCode);
 	
 	//过压保护检测

User/Src/remain_distance.c

@@ -441,7 +441,7 @@ void RD_SaveAndUpdateInfo(MC_GearSt_Struct_t GearSt, MC_AssistRunMode_Struct_t M
 */
 uint8_t Battery_SocCal(Battery_Info_t* p_Battery_Info, uint8_t SOC_Old, uint8_t Vol_Design)
 {
-  static uint16_t TimeDelayCnt = 0;
+   static uint16_t TimeDelayCnt = 0;
 	static uint8_t Result = 0, Result_Pre=0;
 	static TrueOrFalse_Flag_Struct_t InitFlag = FALSE;
 	uint16_t i;
@@ -449,6 +449,7 @@ uint8_t Battery_SocCal(Battery_Info_t* p_Battery_Info, uint8_t SOC_Old, uint8_t
 	uint32_t batteryTotalQ, batteryRemainQ;
 	static uint8_t u8LoopCnt = 0;
 	static uint16_t u16MaxVoltage = 0;
+  static uint32_t u32VolSum = 0;
 	static TrueOrFalse_Flag_Struct_t FlagFristCal = TRUE;
 	
 	TableNum = sizeof(battery_VoltageQuantity) / 4;
@@ -457,18 +458,38 @@ uint8_t Battery_SocCal(Battery_Info_t* p_Battery_Info, uint8_t SOC_Old, uint8_t
 	
 	if(InitFlag == FALSE) //初始化动态显示百分比
 	{
-	  TimeDelayCnt++;
-		if(TimeDelayCnt <= 10) return 0;
-	  else if(TimeDelayCnt <= 15) return 10;
-	  else if(TimeDelayCnt <= 20) return 25;
-	  else if(TimeDelayCnt <= 25) return 45;
-	  else if(TimeDelayCnt <= 30) return 65;
-	  else if(TimeDelayCnt <= 35) return 85;
+	  if(HAL_GetTick() < 2500)
+			return 0;
 		else
 		{
-		  InitFlag = TRUE;
-			return 100;
-		}
+			TimeDelayCnt++;
+			u32VolSum += p_Battery_Info->u16CurVoltage;
+			if(TimeDelayCnt <= 1) return 25;
+			else if(TimeDelayCnt <= 3) return 50;
+			else if(TimeDelayCnt <= 5) return 75;
+			else if(TimeDelayCnt <= 7) return 100;
+			else
+			{
+				InitFlag = TRUE;
+				u16MaxVoltage = (Vol_Design == 24) ? (uint16_t)(u32VolSum >> 3) * 10 / 7
+																						 : ((Vol_Design == 48) ? (uint16_t)(u32VolSum >> 3) * 10 / 13
+																																	 : (uint16_t)(u32VolSum >> 3));	
+				//查表计算SOC
+				for(i=0; i<TableNum; i++)
+				{
+					if(battery_VoltageQuantity[i][0] <= u16MaxVoltage)
+					{
+						batteryRemainQ = batteryTotalQ - battery_VoltageQuantity[i][1]; //A*s
+						break;
+					}
+					else//电池电压低于最小值
+					{
+						batteryRemainQ = 0;
+					}
+				}				 
+				return batteryRemainQ * 100 / batteryTotalQ;
+			}
+		}		
 	}
 	else	//初始化后根据电压平均值计算百分比
 	{
@@ -477,24 +498,15 @@ uint8_t Battery_SocCal(Battery_Info_t* p_Battery_Info, uint8_t SOC_Old, uint8_t
 		
 		if(p_Battery_Info->BFlagCalSoc == TRUE)
 		{
-			if(FlagFristCal == TRUE) //第一次计算采用当前值
-			{
-				u16MaxVoltage = (Vol_Design == 24) ? (uint16_t)(p_Battery_Info->u32TotalBusVoltage / 15000) * 10 / 7
-				                                   : ((Vol_Design == 48) ? (uint16_t)(p_Battery_Info->u32TotalBusVoltage / 15000) * 10 / 13
-				                                                         : (uint16_t)(p_Battery_Info->u32TotalBusVoltage / 15000));
-				FlagFristCal = FALSE;
-			}
-			else //后面取12个值的最大值
+			//后面取12个值的最大值		
+			p_Battery_Info->u16BusAverageVol[u8LoopCnt++] = (uint16_t)(p_Battery_Info->u32TotalBusVoltage / 15000);
+			if(u8LoopCnt >= 12)
 			{
-				p_Battery_Info->u16BusAverageVol[u8LoopCnt++] = (uint16_t)(p_Battery_Info->u32TotalBusVoltage / 15000);
-				if(u8LoopCnt >= 12)
-				{
-					u16MaxVoltage = (Vol_Design == 24) ? GetMaxData(p_Battery_Info->u16BusAverageVol, 12) * 10 / 7
-				                                     : ((Vol_Design == 48) ? GetMaxData(p_Battery_Info->u16BusAverageVol, 12) * 10 / 13
-				                                                           : GetMaxData(p_Battery_Info->u16BusAverageVol, 12));				
-					u8LoopCnt = 0;
-				}
-			}
+				u16MaxVoltage = (Vol_Design == 24) ? GetMaxData(p_Battery_Info->u16BusAverageVol, 12) * 10 / 7
+																					 : ((Vol_Design == 48) ? GetMaxData(p_Battery_Info->u16BusAverageVol, 12) * 10 / 13
+																																 : GetMaxData(p_Battery_Info->u16BusAverageVol, 12));				
+				u8LoopCnt = 0;
+			}			
 			
 			//查表计算SOC
 			for(i=0; i<TableNum; i++)

User/Src/tasks.c

@@ -89,6 +89,8 @@ void HAL_SYSTICK_Callback(void)
 	if(TimeCnt_10ms >= 10)
 	{
 	  TimeCnt_10ms = 0;
+      //计算整车传动比
+      BikeRatioCal_Process(MC_RunInfo.MotorSpeed, MC_RunInfo.Cadence, MC_RunInfo.BikeSpeed, &Bike_RatioCalParam);
 
 	}
 	
@@ -108,8 +110,7 @@ void HAL_SYSTICK_Callback(void)
 	  TimeCnt_100ms = 0;
 	  //踏频计算滑动均值滤波
 	  MC_RunInfo.Cadence = MovingAverageFilter(MC_CadenceResult.Cadence_Data, MC_Cadence_Array, sizeof(MC_Cadence_Array) / 2);
-	  //计算整车传动比
-      BikeRatioCal_Process(MC_RunInfo.MotorSpeed, MC_RunInfo.Cadence, MC_RunInfo.BikeSpeed, &Bike_RatioCalParam);
+	  
 	}
 	
 	//200ms任务
@@ -152,9 +153,16 @@ void MC_RunInfo_Update(void)
 	if((HAL_GetTick() - PeriodTimeCnt) >= 200)
 	{
 	  PeriodTimeCnt = HAL_GetTick();
-		
-		//计算电功率
-		MC_RunInfo.Power = ((uint32_t)MC_RunInfo.BusCurrent) * 25 / (MC_ConfigParam1.CurrentLimit * 100);
+				
+		//计算电功率，额定功率高5位用于显示功率分频系数，低11位额定功率
+		if((MC_MotorParam.Rate_Power >> 11) == 0) //旧程序未配
+		{
+		  MC_RunInfo.Power = ((uint32_t)MC_RunInfo.BusCurrent) * 250 / (MC_ConfigParam1.CurrentLimit * 1000);
+		}
+		else //新程序高5位为显示最大功率分频系数，最大显示功率 = 配置额定功率 * 分频系数 / 32
+		{
+		  MC_RunInfo.Power = ((uint32_t)MC_RunInfo.BusCurrent) * (((MC_MotorParam.Rate_Power & 0x07FF) * ((MC_MotorParam.Rate_Power >> 11) + 1)) >> 5) / (MC_ConfigParam1.CurrentLimit * 1000);
+		}
 		MC_RunInfo.Power = (MC_RunInfo.Power < 20) ? 0 : MC_RunInfo.Power;
 		
 		//更新踏频方向
@@ -665,7 +673,7 @@ void MC_CanRxCheck_Process(MC_SupportFlag_Struct_t NoPBU_Flag, MC_SupportFlag_St
 		//BMS通信状态检测
 		if(IsComOK_BMS.IsOK_Flag == TRUE)
 		{
-			if((HAL_GetTick() - IsComOK_BMS.OK_TrigTime) > 1000)  
+			if((HAL_GetTick() - IsComOK_BMS.OK_TrigTime) > 5000)  
 			{  
 				IsComOK_BMS.IsOK_Flag = FALSE;
 				DeviceOnLine_Status.Status_Bit.BMS_OffLine = 1;
@@ -974,33 +982,36 @@ void NoPBUMode_Ini( void )
 //车辆传动比计算，运行周期100ms
 void BikeRatioCal_Process(uint16_t MotorSpeed, uint16_t Cadence, uint16_t BikeSpeed, Bike_RatioCal_Struct_t* p_Bike_RatioCal)
 {
-  static uint8_t Cnt = 0;
-	uint8_t Cal_K = 0;
+    uint8_t Cal_K = 0;
+	uint16_t AccCnt, DecCnt;
 	//车辆静止或滑行时不计算
 	if((BikeSpeed < 30) || ((BikeSpeed >= 30) && (MotorSpeed < 100) && (Cadence < 10)))
 	{
-	    return;
+	  p_Bike_RatioCal->RatioPer = p_Bike_RatioCal->RatioDefault;
+		p_Bike_RatioCal->RatioResult = p_Bike_RatioCal->RatioDefault;
+		p_Bike_RatioCal->RatioFlt = p_Bike_RatioCal->RatioDefault;
+		p_Bike_RatioCal->RatioFltSum = 0;
+		return;
 	}	
-	//根据车速、电机转速、踏频计算传动系数
-	p_Bike_RatioCal->Ratio_Per = (((uint32_t)BikeSpeed << 18) * 10) / ((((uint32_t)MotorSpeed << 8) > ((uint32_t)Cadence * 2795)) ? ((uint32_t)MotorSpeed << 8) : ((uint32_t)Cadence * 2795));
+	//根据车速、电机转速、踏频计算传动系数，系数 = 车速 / 电机转速 * 1024，其中车速单位为km/h，并放大了10倍
+	p_Bike_RatioCal->RatioPer = (((uint32_t)BikeSpeed << 18) * 10) / ((((uint32_t)MotorSpeed << 8) > ((uint32_t)Cadence * 2795)) ? ((uint32_t)MotorSpeed << 8) : ((uint32_t)Cadence * 2795));
 	//限制计算结果
-	p_Bike_RatioCal->Ratio_Per = (p_Bike_RatioCal->Ratio_Per < 100) ? 100 : ((p_Bike_RatioCal->Ratio_Per > 10000) ? 10000 : p_Bike_RatioCal->Ratio_Per);
-	//判断换挡是否完成
-	p_Bike_RatioCal->Ratio_Array[Cnt++] = p_Bike_RatioCal->Ratio_Per;
-	if(Cnt >= 50)
-	{
-		GetMaxMinAvgData(p_Bike_RatioCal->Ratio_Array, 50, &p_Bike_RatioCal->Ratio_Max, &p_Bike_RatioCal->Ratio_Min, &p_Bike_RatioCal->Ratio_Avg);
-		Cal_K = ((p_Bike_RatioCal->Ratio_Max + p_Bike_RatioCal->Ratio_Min) >> 1) * 100 / p_Bike_RatioCal->Ratio_Avg;
-		if((Cal_K < 120) && (Cal_K > 80))
-		{
-		  p_Bike_RatioCal->Ratio_Result = p_Bike_RatioCal->Ratio_Avg;
-			p_Bike_RatioCal->Ratio_ShiftFlag = TRUE;
-		}
-		else
-		{
-		  p_Bike_RatioCal->Ratio_ShiftFlag = FALSE;
-		}
-		Cnt = 0;
-	}
+	p_Bike_RatioCal->RatioPer = (p_Bike_RatioCal->RatioPer < 500) ? 500 : ((p_Bike_RatioCal->RatioPer > 8000) ? 8000 : p_Bike_RatioCal->RatioPer);
+	//计算结果滤波
+	p_Bike_RatioCal->RatioFltSum += ((p_Bike_RatioCal->RatioPer << 10) - p_Bike_RatioCal->RatioFltSum) >> 5;
+	p_Bike_RatioCal->RatioFlt = p_Bike_RatioCal->RatioFltSum >> 10;
+    //目标值计算
+	#if 0
+    AccCnt = p_Bike_RatioCal->TargetAcc;
+	DecCnt = p_Bike_RatioCal->TargetDec;
+	if(p_Bike_RatioCal->RatioFlt - p_Bike_RatioCal->RatioResult >= AccCnt)
+		p_Bike_RatioCal->RatioResult += AccCnt;
+	else if(p_Bike_RatioCal->RatioResult - p_Bike_RatioCal->RatioFlt >= DecCnt)
+		p_Bike_RatioCal->RatioResult -= DecCnt;
+	else
+		p_Bike_RatioCal->RatioResult = p_Bike_RatioCal->RatioFlt;
+	#else
+	  p_Bike_RatioCal->RatioResult = p_Bike_RatioCal->RatioFlt;
+	#endif
 }
 /**************************全局函数定义结束*****************/

User/Src/var.c

@@ -48,7 +48,7 @@ uint16_t HardwareVersion_AD=0;                            //硬
 TrueOrFalse_Flag_Struct_t VersionIdentifyFinishedFlag = FALSE; //硬件识别结束标识
 TrueOrFalse_Flag_Struct_t PowerDown_SaveFlag = FALSE;          //断电标识
 TrueOrFalse_Flag_Struct_t IsFirstPowerOnFlag = FALSE;          //首次开机标识
-Bike_RatioCal_Struct_t Bike_RatioCalParam = {0,};
+Bike_RatioCal_Struct_t Bike_RatioCalParam = {0,0,0,100,10,0,0};//传动比计算
 
 //BMS默认设计信息
 const BMS_DesignInfo_Struct_t BMS_DesignInfo_Default =
@@ -125,6 +125,7 @@ const MC_TorqueCorrectParam_Struct_t MC_TorqueCorrectParam_Default =
 };
 
 //MC默认马达参数，占用16bytes
+#if defined (VOLANS_36V)
 const MC_MotorParam_Struct_t MC_MotorParam_Default =
 {
   (uint16_t)250,    //W
@@ -135,6 +136,18 @@ const MC_MotorParam_Struct_t MC_MotorParam_Default =
 	(uint16_t)36000,  //mV
 	(uint8_t)36       //V
 };
+#elif defined (VOLANS_48V)
+const MC_MotorParam_Struct_t MC_MotorParam_Default =
+{
+  (uint16_t)250,    //W
+	(uint16_t)1600,   //rpm
+	(uint16_t)200,    //mohm
+	(uint16_t)10,     //mH
+	(uint16_t)10,     //mH
+	(uint16_t)48000,  //mV
+	(uint8_t)48       //V
+};
+#endif
 
 //MC默认历史信息，占用48bytes
 const MC_RunLog1_Struct_t MC_RunLog1_Default =
@@ -463,7 +476,7 @@ void Var_SetToDefaultParam(void)
 	//力矩传感器校正参数
 	memcpy((uint8_t*)&MC_TorqueCorrectParam.StarData, (uint8_t*)&MC_TorqueCorrectParam_Default.StarData, sizeof(MC_TorqueCorrectParam_Default));
 	
-    //配置参数1
+  //配置参数1
 	memcpy((uint8_t*)&MC_ConfigParam1.GasCtrlMode_Param, (uint8_t*)&MC_ConfigParam1_Default.GasCtrlMode_Param, sizeof(MC_ConfigParam1_Default));
 	MC_GasMode_Param.Mode = MC_ConfigParam1.GasCtrlMode_Param;
 	
@@ -553,11 +566,10 @@ void Var_Init(void)
     //MC存储数据初始化为默认值
 	Var_SetToDefaultParam();
 	Var_SetToDefaultLog();
-
-	//传动比计算初始值
-	Bike_RatioCalParam.Ratio_Per = (uint32_t)((MC_ConfigParam1.TeethNum_F * (MC_ConfigParam1.WheelSize + MC_ConfigParam1.WheelSizeAdj) * 60) << 10) / (4550 * MC_ConfigParam1.TeethNum_B);
-	Bike_RatioCalParam.Ratio_Result = Bike_RatioCalParam.Ratio_Per;
-	Bike_RatioCalParam.Ratio_ShiftFlag = FALSE;
+	
+	//传动比计算初始值，车速 = 电机转速 / 4.55 * 前牙盘 / 后牙盘* 周长(cm) * 60 / 1000，周长按cm算相当于放大100倍
+	Bike_RatioCalParam.RatioDefault = (uint32_t)((MC_ConfigParam1.TeethNum_F * (MC_ConfigParam1.WheelSize + MC_ConfigParam1.WheelSizeAdj) * 60) << 10) / (4550 * MC_ConfigParam1.TeethNum_B);
+	Bike_RatioCalParam.RatioResult = Bike_RatioCalParam.RatioDefault;
 }
 
 //根据电机型号系列号调用不同的助力参数

修改说明.txt

@@ -428,7 +428,142 @@ V6.0.2_20211012
 4、删除TIM1 Break的中断配置；
 5、增加前100km清除TRIP时清除一次ODO功能。
 
-
+V6.1.0_20211202
+1、增加识别MCU品牌的代码，加入硬件版本号的第11个字节；
+2、解决转把模式无法检测速度传感器故障的问题；
+3、增加根据SOC限流的处理；
+4、修改低压保护的处理方式，根据BMS通信状态分别处理；
+5、修改关机处理的等待时间，由5s调整到1s，解决仪表关机到下次开机时间很短导致误报MCU故障的问题；
+6、低压保护默认值调整为30V。
+
+V6.1.0_20220407
+1、添加硬件版本的自动识别功能,如有TE则优先从TE获取硬件版本，没有TE则通过ADC采集获取
+2、添加前灯6V电压控制使能管脚，PB4与PB5同时作为前灯6V控制端口
+3、屏蔽TE的故障检测功能
+4、添加批处理自动命名的功能
+
+V6.1.0_20220507
+1、通过硬件判断硬件是否有反相器芯片
+
+V6.2.0_20220509
+1、修改hall电角度
+
+V6.2.0_20220519
+1、ADC1_Result_Filt[ADC1_RANK_HARDWARE_VER]要等初始化完后才会更新，板子第一次运行程序时会擦写EEPROM，
+初始化完成时间在3.4s左右，这会导致硬件版本识别错误。新建一个变量HardwareVersion_AD作为判断值，
+HardwareVersion_AD变量在ADC启动后就开始更新。
+2、硬件版本识别函数增加判断初始化完成时间，若初始化完成时间大于1.8s,则硬件判断时间延长200ms.
+3、同步母线电压与母线电流算法
+4、将串口3的GPIO修改为上拉输入
+
+V6.2.0_20220531
+1、同步单向器打滑故障检测代码
+2、同步解决在指拨突然松开电机会反转的问题
+
+V6.2.0_20220609
+1、同步剩余里程的代码
+
+V6.3.0_20220616
+1、硬件版本故障检测增加通讯标志记录；
+2、修改温度保护逻辑，删掉MCU温度；
+
+V6.3.0_20220714
+1、修改NTC表格，将硬件上NTC上拉电阻由100K修改为20K
+
+V6.3.0_20220727
+1、修改NTC处理函数，根据识别的硬件版本执行不同的处理；旧电路板按照原来逻辑处理，新电路板增加一路MOS管NTC，新增温度系数表；
+2、增加长转测试代码；
+3、波特率由125K改为250K;
+4、死区时间由100ns改为500ns;
+5、Q轴电流环输出下限参数由-32768改为-100；
+6、踏频霍尔和电机霍尔重复读取三次，三次都一样才认为霍尔正常；
+7、力矩传感器无力矩故障检测时间延长为15s;
+8、传感器短路时间由200ms延长为1s;
+9、指拨模式下降速度由1s延长为5.5s，去掉下限限制；
+10、增加PCB温度保护限制；
+
+V6.3.0_20220727
+1、增加力矩传感器两点校正函数，根据使能标志判断是否使用校正功能；
+2、死区时间由100ns改为800ns；
+
+V6.3.0_20220907
+1、母线电流放大倍数改为8.2倍，通过硬件版本识别采用不同的处理；
+2、死区时间延长为800ns;
+
+V6.3.0_20220909
+1、修改软件解决TTKZ010D电路板温度测量异常问题
+
+V6.3.0_20221009
+1、增加掉电保护功能；
+2、屏蔽温度故障检测；
+
+V6.3.0_20221011
+1、优化掉电保护函数
+
+V6.3.0_20221012
+1、增加掉电保存续航里程功能；
+
+V6.3.0_20221028
+1、开机3s后才能启动电机；
+
+V6.2.0_20221104（版本重新定义）
+1、250K和125K程序共用，通过宏定义来生成不同的文件；
+
+V6.2.0_20221107
+1、优化VolansPlus电机骑行助力体验
+
+V6.2.0_20221115
+1、硬件识别完后若是新主控板，则采用增大后的助力参数；
+2、停机力矩缩小一半；
+
+V6.2.0_20221117
+1、优化指拨推行体验，加快推行响应时间；
+2、若两点校正功能使能，则调用新的助力参数；
+3、增加反转并拨指拨工况检测功能，若检测到该工况则启动恒压制动功能；
+
+V6.2.1_20230323
+1、刹车检测时间由100ms减小为10ms；
+2、退出指拨模式时下降速度由9增大为16；
+
+V6.2.1_20230907
+开机前2s不处理开关灯。
+
+V6.2.1_20230915
+1、修改SOC计算算法；
+2、增加限速起始和结束值的设定；
+3、开灯延迟2s；
+4、优化首次开机的判断逻辑。
+
+20231121合并Enviolo分支，修改点如下：
+1、开机前3s判断变速器是否在线，离线时运行信息发送0xF0；
+2、变速器在线时，可通过仪表设置模式（手动模式、自动模式）和修改参数（挡位数量、最低踏频、最高踏频）；
+3、手动模式调整变速比，骑行时变速器会响应；
+4、自动模式设置目标踏频，骑行时变速器会自动调整；
+5、修改挡位数量后，可及时更新变速比对照表
+6、增加校准相关功能，进入校准时发送5次校准指令给变速器，同时发送踩踏提示给仪表。
+7、仪表修改轮胎周长后，电机发送给变速器的周长值同步变更。
+8、调整变速器的过滤器设置为FIFO1，增加FIFO1的中断
+9、针对FIFO0和FIFO1增加独立的接收中断回调函数。
+10、修改CAN采样率。
+
+V6.2.1_20231121
+1、修改转把模式控制方式，可通过配置参数设置速度模式或力矩模式、挡位限制或不限制功率、零速启动或带速启动、指拨限速配置；
+2、用户参数2增加骑行助力参数，包含各挡位最大力矩增益和最大电流增益；
+3、增加传动比计算函数（未测）；
+4、增加仪表设置限速微调、骑行助力参数。
+5、速度来源设为通信时，根据变速器的信号计算车速和里程。
+
+V6.2.1_20231121-1
+1、变速器通信超时时间设置3s；
+2、增加根据SOC计算最大电流和最大车速系数，指拨和助力模式根据SOC限制最大电流和最大车速；
+3、转把启动偏移电压由0.1V调整为1.25V；
+4、欠压保护值高4位改用欠压保护方式和保护延时设置，bit15为0-根据电压保护，bit15为1-根据SOC保护，bit14~bit12用于设置保护延时时间，保护延时=5+设置值*10，同时修改欠压保护处理；
+5、修改开机电量初始化时间；
+6、运行信息电功率采用额定功率和高5位的分频系数进行计算，计算方法如下：
+   发送功率 = 母线电流 / 最大电流 * (额定功率 * (分频系数 + 1) / 32)
+7、BMS通信状态检测超时时间设置5s
+8、修改传动比计算方法；
+9、转把速度模式采用新计算的传动比（目前测试小飞车速上不去，待查）