2.1.5_20201202 TC033001-MS2001-V0r1

1、限流强制改为16A；
2、踏频模式还原为以前的力矩控制方式；
3、指拨模式去掉低踏频限流。

Core/Src/main.c

@@ -205,6 +205,8 @@ int main(void)
 	
 	//³õʼ»¯Íê³É±êÖ¾
 	IsInitFinish_Flag = TRUE;
+  
+	MC_ConfigParam1.CurrentLimit = 16;
 
   /* USER CODE END 2 */
 

User/Src/motor_control.c

@@ -606,120 +606,129 @@ MC_CalParam_Struct_t MC_AssistRunMode_Walk_Process(MC_WorkMode_Struct_t p_MC_Wor
 MC_CalParam_Struct_t MC_AssistRunMode_Cadence_Process(MC_CadenceResult_Struct_t CadenceData, ADC_SensorData_Struct_t AdcSenorData, MC_GearSt_Struct_t GearSt, MC_SupportFlag_Struct_t GasCtrlMode)
 {
 	MC_CalParam_Struct_t p_MC_CalParam = {MC_AssistRunMode_INVALID, 0,	0, RESET};
-	int16_t TorQueBySpd = 0;                   //转速外环输出
-	int32_t Ref_Speed_Temp;
-	int16_t SpdMotorByIdc = 0;                 //限流内环输出
-	uint16_t MotorSpeedSet = 0;                //电机转速设定，根据踏频输入计算
-	uint16_t TorqueStartData, TorqueStopData;  //低力矩停机值
-	uint16_t TorqueStopDelayTime = 0;          //低力矩停机延时
-	static uint16_t Cadence_Old = 0;           //踏频上一刻值
-	static int16_t Cadence_Diff_Sum = 0;       //踏频变化累积值
-	static uint32_t TorqueStopDelayTimeCnt = 0;//低力矩停机计时
+  uint8_t TorqueAccStep = 0;//力矩上升斜率
+	uint8_t TorqueDecStep = 0;//力矩下降斜率
+	uint16_t TorqueStartData, TorqueStopData;//力矩启动值，力矩停机值
+	int16_t Torque_Temp;
+	int32_t Torque_Ref_Temp;
+	static uint32_t TorqueStopDelayTimeCnt = 0; //低力矩停机计时
+	uint16_t TorqueStopDelayTime;
+	static int16_t IqRefByInPower;           //限流计算结果
+  static uint16_t CurrentLimitPresent;     //限流实际值，做升降速处理
+	uint16_t CurrentLimitSet;                //限流设置值，不同助力档位更新
 	static FlagStatus IsEnterGasMode = RESET;
-	static uint16_t CurrentLimitPresent;       //限流实际值，做升降速处理
-	uint16_t CurrentLimitSet;                  //限流设置值，不同助力档位更新
-	uint16_t SpeedAcc = 32;                    //转速加速曲线，1ms转速升 32 / 32 = 1rpm
-	uint16_t SpeedDec = 8;                     //转速减速曲线，1ms转速降 8 / 32 = 0.25rpm
+	static uint8_t TorqueRefEndUpdateCount = 0;
 	
-	#define CADENCE_MODE_SOFT_SATRT 1
+	#define SOFT_SATRT 1
 	
-	#if CADENCE_MODE_SOFT_SATRT
+	#if SOFT_SATRT
 	static FlagStatus SoftStartFlag = SET;
 	static uint16_t SoftStartDelayTimeCount = 0;
+	uint16_t SoftStartDelayTime = 0;
 	uint16_t SoftStartAcc = 0;
 	#endif
-	
-	MC_CadenceProcess_Param.CadenceInput = MC_RunInfo.Cadence;
-	
-	//根据指拨控制
+
+  //根据指拨控制
 	if((GasCtrlMode == MC_SUPPORT_ENABLE) && (AdcSenorData.GasSensor > 50))
 	{
-	  MC_CadenceProcess_Param.MotorStopLock_Flag = RESET;
+	  MC_TorqueProcess_Param.MotorStopLock_Flag = RESET;
 		//停止判断
 		if(AdcSenorData.GasSensor < 30)
 		{
-		  MC_CadenceProcess_Param.MotorStopLock_Flag = SET;
+		  MC_TorqueProcess_Param.MotorStopLock_Flag = SET;
 		}
-		//设定马达转速
-		MotorSpeedSet = (AdcSenorData.GasSensor * MC_MotorParam.Rate_Speed) >> 11;
-		if(MotorSpeedSet < (MC_CadenceProcess_Param.CadenceInput * 1445) >> 7)
+		//设定马达输出力矩
+		MC_TorqueProcess_Param.TorqueApp = (AdcSenorData.GasSensor * MC_AssisParam.Gear_TURBO.Upper_Iq) >> 11;
+		if(MC_TorqueProcess_Param.TorqueApp < CadenceData.torqueByCadence)
 		{
-		  MotorSpeedSet = (MC_CadenceProcess_Param.CadenceInput * 1445) >> 7;
+		  MC_TorqueProcess_Param.TorqueApp = CadenceData.torqueByCadence;
 		}
-		MotorSpeedSet = MotorSpeedSet > MC_MotorParam.Rate_Speed ? MC_MotorParam.Rate_Speed : MotorSpeedSet;
-		MotorSpeedSet <<= 5;
 		//进入指拨模式标志
 		IsEnterGasMode = SET;
 	}
-	//根据踏频控制
+	
+	//根据踩踏力矩控制
 	else
 	{
-		//低力矩停机
-		TorqueStopData = 60;//(MC_TorqueCorrectParam.StarData < 400) ? 100 : (MC_TorqueCorrectParam.StarData >> 2);
-		if(AdcSenorData.TorqueSensor > TorqueStopData)
-		{
-			TorqueStopDelayTimeCnt = HAL_GetTick();
-			Cadence_Diff_Sum = 0;
-		}
-		else
-		{
-			TorqueStopDelayTime = 2000;
-			Cadence_Diff_Sum += abs(CadenceData.Cadence_Data - Cadence_Old);
-						
-			MC_RunInfo.Ride_Km = Cadence_Diff_Sum;
+			#if 1
 			
-			Cadence_Old = CadenceData.Cadence_Data;
-			if((HAL_GetTick() - TorqueStopDelayTimeCnt) > TorqueStopDelayTime)
-			{			
-				if(Cadence_Diff_Sum < 200)
-				{
-				  MC_CadenceProcess_Param.MotorStopLock_Flag = SET;
-				}
-				else
+			//踩踏力矩输入
+			MC_TorqueProcess_Param.TorqueApp = AdcSenorData.TorqueSensor;
+			
+			#elif 1
+			
+			//输入阶跃
+			MC_TorqueProcess_Param.TorqueApp  = 1000;
+			
+			//踏频设为启动
+			CadenceData.Cadence_Dir = MC_Cadence_Forward;
+			CadenceData.IsStopFlag = FALSE;
+						
+			#endif
+				
+			//低力矩停机
+			TorqueStopData = (MC_TorqueCorrectParam.StarData < 400) ? 100 : (MC_TorqueCorrectParam.StarData >> 2);
+			if(MC_TorqueProcess_Param.TorqueApp >= (TorqueStopData))
+			{
+				TorqueStopDelayTimeCnt = HAL_GetTick();
+			}
+			else
+			{
+//				if(MC_RunInfo.MotorSpeed > 200)
+//				{
+//					TorqueStopDelayTime = 218400 / MC_RunInfo.MotorSpeed; //60s / (电机转速 / 4.55 / 2.4) / 3，曲柄1/3圈
+//				}
+//				else
+//				{
+//					TorqueStopDelayTime = 1200;
+//				}
+//				TorqueStopDelayTime= (TorqueStopDelayTime < 500) ? 500 : TorqueStopDelayTime;
+				TorqueStopDelayTime = 2000;
+				if((HAL_GetTick() - TorqueStopDelayTimeCnt) > TorqueStopDelayTime)//超时1200ms
 				{
-				  TorqueStopDelayTimeCnt = HAL_GetTick();
-			    Cadence_Diff_Sum = 0;
+					MC_TorqueProcess_Param.MotorStopLock_Flag = SET;
 				}
 			}
-		}
-		
-		//启动判断
-		TorqueStartData = (MC_TorqueCorrectParam.StarData < 300 ? 300 : (MC_TorqueCorrectParam.StarData > 700 ? 700 : MC_TorqueCorrectParam.StarData));
-		if(AdcSenorData.TorqueSensor >= TorqueStartData)
-		{
-			MC_CadenceProcess_Param.MotorStopLock_Flag = RESET;
-		}	
-		
-		//踏频反向或踏频停止停机
-		if((CadenceData.Cadence_Dir == MC_Cadence_Backward) ||
-			 (CadenceData.IsStopFlag == TRUE)		
-			)
-		{
-			MC_CadenceProcess_Param.MotorStopLock_Flag = SET;
-		}
-		
-		//根据输入踏频计算电机转速给定值
-//		MotorSpeedSet = (CadenceData.Cadence_Data * 1445) >> 7;
-		MotorSpeedSet = (1872 * CadenceData.Cadence_Data - 4 * CadenceData.Cadence_Data * CadenceData.Cadence_Data) >> 7; 
-//		MotorSpeedSet = (MC_CadenceProcess_Param.CadenceInput < 30) ? (MC_CadenceProcess_Param.CadenceInput * 13448 >> 10)
-//	                                                 	            : ((MC_CadenceProcess_Param.CadenceInput * 10547 + 87040) >> 10); 
-		MotorSpeedSet = MotorSpeedSet > MC_MotorParam.Rate_Speed ? MC_MotorParam.Rate_Speed : MotorSpeedSet;
-		MotorSpeedSet = MotorSpeedSet < 300 ? 300 : MotorSpeedSet;
-		MotorSpeedSet <<= 5;
-		//进入指拨模式标志
-		IsEnterGasMode = RESET;
+			//启动值判断
+			if(MC_RunInfo.BikeSpeed > 60) 
+			{
+				TorqueStartData =  (MC_TorqueCorrectParam.StarData < 200 ? 150 \
+																																 : (MC_TorqueCorrectParam.StarData > 700 ? 525 \
+																																																				 : (MC_TorqueCorrectParam.StarData * 3 >> 2)));
+			}
+			else
+			{
+				TorqueStartData =  (MC_TorqueCorrectParam.StarData < 200 ? 150 \
+																																 : (MC_TorqueCorrectParam.StarData > 700 ? 525 \
+																																																				 : MC_TorqueCorrectParam.StarData));
+			}
+			if(MC_TorqueProcess_Param.TorqueApp >= TorqueStartData)
+			{
+				 MC_TorqueProcess_Param.MotorStopLock_Flag = RESET;
+			}
+			//踏频反向或踏频停止停机
+			if((CadenceData.Cadence_Dir == MC_Cadence_Backward) ||
+				 (CadenceData.IsStopFlag == TRUE)		
+				)
+			{
+				MC_TorqueProcess_Param.MotorStopLock_Flag = SET;
+			}
+			//设定输入力矩
+		  MC_TorqueProcess_Param.TorqueApp = CadenceData.torqueByCadence;
+			//进入指拨模式标志
+		  IsEnterGasMode = RESET;
 	}
 	
 	//停机状态，延时处理
-	if(MC_CadenceProcess_Param.MotorStopLock_Flag == SET)
+	if(MC_TorqueProcess_Param.MotorStopLock_Flag == SET)
 	{
-	  if(MC_CadenceProcess_Param.MotorSpeedSetBegin < 35)
+	  if(MC_TorqueProcess_Param.TorqueRefEnd <= 7)
 		{
-		  MC_CadenceProcess_Param.MotorSpeedSetBegin = 0;
+		  MC_TorqueProcess_Param.TorqueRefEnd = 0;
 			//停机处理
 			MC_MotorStop(&MC_StarFlag);
 			
-			#if CADENCE_MODE_SOFT_SATRT
+			#if SOFT_SATRT
 			//缓启动标志置位
 			SoftStartFlag = SET;
 			SoftStartDelayTimeCount = 0;
@@ -727,111 +736,414 @@ MC_CalParam_Struct_t MC_AssistRunMode_Cadence_Process(MC_CadenceResult_Struct_t
 		}
 		else
 		{
-		  MC_CadenceProcess_Param.MotorSpeedSetBegin -= 32;  //这里影响到停止踩踏后的断电时间, 1ms降32 / 32 = 1rpm
+		  MC_TorqueProcess_Param.TorqueRefEnd -= 7;  //这里影响到停止踩踏后的断电时间
 			MC_MotorStar(&MC_StarFlag);
 		}
 	}
-	//随档位给定电机输出助力大小
+	//力矩给定升降速处理
 	else
 	{
-		//速度环
-		#if CADENCE_MODE_SOFT_SATRT
-		if(SoftStartFlag == SET)
-		{
-			if(SoftStartDelayTimeCount <= 1024)
-			{
-				SoftStartDelayTimeCount++;
-				SoftStartAcc = SoftStartDelayTimeCount >> 5;
-			  SpeedAcc = SoftStartAcc;
-			}
-			else
-			{
-			  SoftStartFlag = RESET;
-				SoftStartDelayTimeCount = 0;
-			}
-		}
-		else
-		{
-		  SpeedAcc = 32;
-		}
-		#endif
-		
-		if(MC_CadenceProcess_Param.MotorSpeedSetBegin < MotorSpeedSet - 10)//设定电机转速加减速曲线
-		{
-			MC_CadenceProcess_Param.MotorSpeedSetBegin += SpeedAcc;
-		}
-		else if(MC_CadenceProcess_Param.MotorSpeedSetBegin > MotorSpeedSet + 10)
+		//指拨模式限流值
+		if(IsEnterGasMode == SET)
 		{
-			if(MC_CadenceProcess_Param.MotorSpeedSetBegin > SpeedDec)
-			{
-				MC_CadenceProcess_Param.MotorSpeedSetBegin -= SpeedDec;
-			}
-			else
-			{
-				MC_CadenceProcess_Param.MotorSpeedSetBegin = 0;
-			}
+		  Torque_Temp = MC_TorqueProcess_Param.TorqueApp;
+			TorqueAccStep = 3;
+			TorqueDecStep = 7;
+			//给定上限
+		  Torque_Temp = (Torque_Temp > MC_AssisParam.Gear_TURBO.Upper_Iq) ? MC_AssisParam.Gear_TURBO.Upper_Iq : Torque_Temp;
+			CurrentLimitSet = (uint32_t)(MC_AssisParam.Gear_TURBO.CurrentMax_K * MC_ConfigParam1.CurrentLimit * 1000 >> 17) * 100;
+			CurrentLimitPresent = MC_DataSet_Linear_Process(CurrentLimitSet, CurrentLimitPresent, 5 ,1);
+			PID_IMax.hLower_Limit_Output = -(MC_AssisParam.Gear_TURBO.Upper_Iq);   //Lower Limit for Output limitation
+			PID_IMax.hUpper_Limit_Output = 0; //Upper Limit for Output limitation
+			PID_IMax.wLower_Limit_Integral = -(MC_AssisParam.Gear_TURBO.Upper_Iq << 10); // 放大1024
+			PID_IMax.wUpper_Limit_Integral = 0; // 放大1024
 		}
 		else
 		{
-			MC_CadenceProcess_Param.MotorSpeedSetBegin = MotorSpeedSet;
-		}
-		TorQueBySpd = PID_Regulator((MC_CadenceProcess_Param.MotorSpeedSetBegin >> 5), MC_RunInfo.MotorSpeed, &PID_MotorSpd); // 电机速度闭环输出
-		
-		//限流控制
-		if(IsEnterGasMode == SET) //指拨模式，全功率输出
-		{
-			SpdMotorByIdc = PID_Regulator((MC_ConfigParam1.CurrentLimit * 1000) >> 7, MC_RunInfo.BusCurrent >> 7, &PID_ConstantPower); // 母线电流闭环
-		}
-		else //根据档位设定最大电流
-		{
-		  switch(GearSt)
+			//按照助力档位调节力矩输入值
+			switch(GearSt)
 			{
-			  case MC_GearSt_Cadence_ECO:
+				case MC_GearSt_Cadence_ECO:
 				{
+					//控制输入给定加速斜率
+					if(MC_ConfigParam1.UserAdjParam_ECO.StarModel_GAIN <= 90)
+					{
+						TorqueAccStep = MC_AssisParam.Gear_ECO.AccCnt - 1;
+					}
+					else if(MC_ConfigParam1.UserAdjParam_ECO.StarModel_GAIN >= 110)
+					{
+						TorqueAccStep = MC_AssisParam.Gear_ECO.AccCnt + 1;
+					}
+					else
+					{
+						TorqueAccStep = MC_AssisParam.Gear_ECO.AccCnt;
+					}
+					TorqueAccStep = (TorqueAccStep <= 0) ? 1 : TorqueAccStep;
+					//控制输入给定减速斜率
+					TorqueDecStep = MC_AssisParam.Gear_ECO.DecCnt;
+					//调节电机输出功率
+					if(CadenceData.Cadence_Data < 50)//输出功率与输入力矩成正比，等效于踏频采用固定值50rpm
+					{
+						Torque_Temp = (uint16_t)((uint32_t)(MC_TorqueProcess_Param.TorqueApp * Coefficient_GainCal(MC_AssisParam.Gear_ECO.Gain_K >> 1, MC_AssisParam.Gear_ECO.Gain_K, MC_AssisParam.Gear_ECO.TorqueApp_TH, MC_TorqueProcess_Param.TorqueApp)) >> 10);
+						Torque_Temp = (MC_RunInfo.MotorSpeed < 546) ? MC_AssisParam.Gear_ECO.Upper_Iq 
+																												: Torque_Temp * 120 / (MC_RunInfo.MotorSpeed * 20 / 91);
+					}
+					else if((CadenceData.Cadence_Data >= 50) && (CadenceData.Cadence_Data < 90))//输出功率与输入力矩成正比
+					{
+						Torque_Temp = (uint16_t)((uint32_t)(MC_TorqueProcess_Param.TorqueApp * Coefficient_GainCal(MC_AssisParam.Gear_ECO.Gain_K >> 1, MC_AssisParam.Gear_ECO.Gain_K, MC_AssisParam.Gear_ECO.TorqueApp_TH, MC_TorqueProcess_Param.TorqueApp)) >> 10);
+						Torque_Temp = (MC_RunInfo.MotorSpeed < 546) ? MC_AssisParam.Gear_ECO.Upper_Iq 
+																												: ((MC_RunInfo.MotorSpeed < 983) ? Torque_Temp * 216 / (MC_RunInfo.MotorSpeed * 20 / 91) 
+																																												 : Torque_Temp * CadenceData.Cadence_Data * 24 / 10 / (MC_RunInfo.MotorSpeed * 20 / 91));
+					}
+					else//全功率输出
+					{
+						Torque_Temp = MC_AssisParam.Gear_ECO.Upper_Iq;
+					}
+					//根据助力增益调节助力比
+					Torque_Temp = Torque_Temp * MC_ConfigParam1.UserAdjParam_ECO.Assist_K_GAIN / 100;
+					//给定下限
+					Torque_Temp = (Torque_Temp < MC_AssisParam.Gear_ECO.Lower_Iq) ? MC_AssisParam.Gear_ECO.Lower_Iq : Torque_Temp;
+					//给定上限
+					Torque_Temp = (Torque_Temp > MC_AssisParam.Gear_ECO.Upper_Iq) ? MC_AssisParam.Gear_ECO.Upper_Iq : Torque_Temp;
+					//限流参数设置
 					CurrentLimitSet = (uint32_t)(MC_AssisParam.Gear_ECO.CurrentMax_K * MC_ConfigParam1.CurrentLimit * 1000 >> 17) * 100;
 					CurrentLimitPresent = MC_DataSet_Linear_Process(CurrentLimitSet, CurrentLimitPresent, 5 ,1);
+					PID_IMax.hLower_Limit_Output = -(MC_AssisParam.Gear_ECO.Upper_Iq);   //Lower Limit for Output limitation
+					PID_IMax.hUpper_Limit_Output = 0; //Upper Limit for Output limitation
+					PID_IMax.wLower_Limit_Integral = -(MC_AssisParam.Gear_ECO.Upper_Iq << 10); // 放大1024
+					PID_IMax.wUpper_Limit_Integral = 0; // 放大1024
 					break;
 				}
 				case MC_GearSt_Cadence_NORM:
 				{
+					//控制输入给定加速斜率
+					if(MC_ConfigParam1.UserAdjParam_NORM.StarModel_GAIN <= 90)
+					{
+						TorqueAccStep = MC_AssisParam.Gear_NORM.AccCnt - 1;
+					}
+					else if(MC_ConfigParam1.UserAdjParam_NORM.StarModel_GAIN >= 110)
+					{
+						TorqueAccStep = MC_AssisParam.Gear_NORM.AccCnt + 1;
+					}
+					else
+					{
+						TorqueAccStep = MC_AssisParam.Gear_NORM.AccCnt;
+					}
+					TorqueAccStep = (TorqueAccStep <= 0) ? 1 : TorqueAccStep;
+					//控制输入给定减速斜率
+					TorqueDecStep = MC_AssisParam.Gear_NORM.DecCnt;
+					//调节电机输出功率
+					if(CadenceData.Cadence_Data < 50)//输出功率与输入力矩成正比，等效于踏频采用固定值50rpm
+					{
+						Torque_Temp = (uint16_t)((uint32_t)(MC_TorqueProcess_Param.TorqueApp * Coefficient_GainCal(MC_AssisParam.Gear_NORM.Gain_K >> 1, MC_AssisParam.Gear_NORM.Gain_K, MC_AssisParam.Gear_NORM.TorqueApp_TH, MC_TorqueProcess_Param.TorqueApp)) >> 10);
+						Torque_Temp = (MC_RunInfo.MotorSpeed < 546) ? MC_AssisParam.Gear_NORM.Upper_Iq 
+																												: Torque_Temp * 120 / (MC_RunInfo.MotorSpeed * 20 / 91);
+					}
+					else if((CadenceData.Cadence_Data >= 50) && (CadenceData.Cadence_Data < 90))//输出功率与输入力矩成正比
+					{
+						Torque_Temp = (uint16_t)((uint32_t)(MC_TorqueProcess_Param.TorqueApp * Coefficient_GainCal(MC_AssisParam.Gear_NORM.Gain_K >> 1, MC_AssisParam.Gear_NORM.Gain_K, MC_AssisParam.Gear_NORM.TorqueApp_TH, MC_TorqueProcess_Param.TorqueApp)) >> 10);
+						Torque_Temp = (MC_RunInfo.MotorSpeed < 546) ? MC_AssisParam.Gear_NORM.Upper_Iq 
+																												: ((MC_RunInfo.MotorSpeed < 983) ? Torque_Temp * 216 / (MC_RunInfo.MotorSpeed * 20 / 91) 
+																																												 : Torque_Temp * CadenceData.Cadence_Data * 24 / 10 / (MC_RunInfo.MotorSpeed * 20 / 91));
+					}
+					else//全功率输出
+					{
+						Torque_Temp = MC_AssisParam.Gear_NORM.Upper_Iq;
+					}
+					//根据助力增益调节助力比
+					Torque_Temp = Torque_Temp * MC_ConfigParam1.UserAdjParam_NORM.Assist_K_GAIN / 100;
+					//给定下限
+					Torque_Temp = (Torque_Temp < MC_AssisParam.Gear_NORM.Lower_Iq) ? MC_AssisParam.Gear_NORM.Lower_Iq : Torque_Temp;
+					//给定上限
+					Torque_Temp = (Torque_Temp > MC_AssisParam.Gear_NORM.Upper_Iq) ? MC_AssisParam.Gear_NORM.Upper_Iq : Torque_Temp;
+					
+					//限流参数设置
 					CurrentLimitSet = (uint32_t)(MC_AssisParam.Gear_NORM.CurrentMax_K * MC_ConfigParam1.CurrentLimit * 1000 >> 17) * 100;
 					CurrentLimitPresent = MC_DataSet_Linear_Process(CurrentLimitSet, CurrentLimitPresent, 5 ,1);
+					PID_IMax.hLower_Limit_Output = -(MC_AssisParam.Gear_NORM.Upper_Iq);   //Lower Limit for Output limitation
+					PID_IMax.hUpper_Limit_Output = 0; //Upper Limit for Output limitation
+					PID_IMax.wLower_Limit_Integral = -(MC_AssisParam.Gear_NORM.Upper_Iq << 10); // 放大1024
+					PID_IMax.wUpper_Limit_Integral = 0; // 放大1024
 					break;
 				}
 				case MC_GearSt_Cadence_SPORT:
 				{
-				  CurrentLimitSet = (uint32_t)(MC_AssisParam.Gear_SPORT.CurrentMax_K * MC_ConfigParam1.CurrentLimit * 1000 >> 17) * MC_CadenceLimit_K;
+					//控制输入给定加速斜率
+					if(MC_ConfigParam1.UserAdjParam_SPORT.StarModel_GAIN <= 90)
+					{
+						TorqueAccStep = MC_AssisParam.Gear_SPORT.AccCnt - 1;
+					}
+					else if(MC_ConfigParam1.UserAdjParam_SPORT.StarModel_GAIN >= 110)
+					{
+						TorqueAccStep = MC_AssisParam.Gear_SPORT.AccCnt + 1;
+					}
+					else
+					{
+						TorqueAccStep = MC_AssisParam.Gear_SPORT.AccCnt;
+					}
+					TorqueAccStep = (TorqueAccStep <= 0) ? 1 : TorqueAccStep;
+					//控制输入给定减速斜率
+					TorqueDecStep = MC_AssisParam.Gear_SPORT.DecCnt;
+					//调节电机输出功率
+					if(CadenceData.Cadence_Data < 50)//输出功率与输入力矩成正比，等效于踏频采用固定值50rpm
+					{
+						Torque_Temp = (uint16_t)((uint32_t)(MC_TorqueProcess_Param.TorqueApp * Coefficient_GainCal(MC_AssisParam.Gear_SPORT.Gain_K >> 1, MC_AssisParam.Gear_SPORT.Gain_K, MC_AssisParam.Gear_SPORT.TorqueApp_TH, MC_TorqueProcess_Param.TorqueApp)) >> 10);
+						Torque_Temp = (MC_RunInfo.MotorSpeed < 546) ? MC_AssisParam.Gear_SPORT.Upper_Iq 
+																												: Torque_Temp * 120 / (MC_RunInfo.MotorSpeed * 20 / 91);
+					}
+					else if((CadenceData.Cadence_Data >= 50) && (CadenceData.Cadence_Data < 90))//输出功率与输入力矩成正比
+					{
+						Torque_Temp = (uint16_t)((uint32_t)(MC_TorqueProcess_Param.TorqueApp * Coefficient_GainCal(MC_AssisParam.Gear_SPORT.Gain_K >> 1, MC_AssisParam.Gear_SPORT.Gain_K, MC_AssisParam.Gear_SPORT.TorqueApp_TH, MC_TorqueProcess_Param.TorqueApp)) >> 10);
+						Torque_Temp = (MC_RunInfo.MotorSpeed < 546) ? MC_AssisParam.Gear_SPORT.Upper_Iq 
+																												: ((MC_RunInfo.MotorSpeed < 983) ? Torque_Temp * 216 / (MC_RunInfo.MotorSpeed * 20 / 91) 
+																																												 : Torque_Temp * CadenceData.Cadence_Data * 24 / 10 / (MC_RunInfo.MotorSpeed * 20 / 91));
+					}
+					else//全功率输出
+					{
+						Torque_Temp = MC_AssisParam.Gear_SPORT.Upper_Iq;
+					}					
+				  //根据助力增益调节助力比
+					Torque_Temp = Torque_Temp * MC_ConfigParam1.UserAdjParam_SPORT.Assist_K_GAIN / 100;
+					//给定下限
+					Torque_Temp = (Torque_Temp < MC_AssisParam.Gear_SPORT.Lower_Iq) ? MC_AssisParam.Gear_SPORT.Lower_Iq : Torque_Temp;
+					//给定上限
+					Torque_Temp = (Torque_Temp > MC_AssisParam.Gear_SPORT.Upper_Iq) ? MC_AssisParam.Gear_SPORT.Upper_Iq : Torque_Temp;
+					//限流参数设置
+					CurrentLimitSet = (uint32_t)(MC_AssisParam.Gear_SPORT.CurrentMax_K * MC_ConfigParam1.CurrentLimit * 1000 >> 17) * MC_CadenceLimit_K;
 					CurrentLimitPresent = MC_DataSet_Linear_Process(CurrentLimitSet, CurrentLimitPresent, 5 ,1);
+					PID_IMax.hLower_Limit_Output = -(MC_AssisParam.Gear_SPORT.Upper_Iq);   //Lower Limit for Output limitation
+					PID_IMax.hUpper_Limit_Output = 0; //Upper Limit for Output limitation
+					PID_IMax.wLower_Limit_Integral = -(MC_AssisParam.Gear_SPORT.Upper_Iq << 10); // 放大1024
+					PID_IMax.wUpper_Limit_Integral = 0; // 放大1024
 					break;
 				}
 				case MC_GearSt_Cadence_TURBO:
 				{
+					//控制输入给定加速斜率
+					if(MC_ConfigParam1.UserAdjParam_TURBO.StarModel_GAIN <= 90)
+					{
+						TorqueAccStep = MC_AssisParam.Gear_TURBO.AccCnt - 1;
+					}
+					else if(MC_ConfigParam1.UserAdjParam_TURBO.StarModel_GAIN >= 110)
+					{
+						TorqueAccStep = MC_AssisParam.Gear_TURBO.AccCnt + 1;
+					}
+					else
+					{
+						TorqueAccStep = MC_AssisParam.Gear_TURBO.AccCnt;
+					}
+					TorqueAccStep = (TorqueAccStep <= 0) ? 1 : TorqueAccStep;
+					//控制输入给定减速斜率
+					TorqueDecStep = MC_AssisParam.Gear_TURBO.DecCnt;
+					//调节电机输出功率
+					if(CadenceData.Cadence_Data < 50)//输出功率与输入力矩成正比，等效于踏频采用固定值50rpm
+					{
+						Torque_Temp = (uint16_t)((uint32_t)(MC_TorqueProcess_Param.TorqueApp * Coefficient_GainCal(MC_AssisParam.Gear_TURBO.Gain_K >> 1, MC_AssisParam.Gear_TURBO.Gain_K, MC_AssisParam.Gear_TURBO.TorqueApp_TH, MC_TorqueProcess_Param.TorqueApp)) >> 10);
+						Torque_Temp = (MC_RunInfo.MotorSpeed < 546) ? MC_AssisParam.Gear_TURBO.Upper_Iq 
+																												: Torque_Temp * 120 / (MC_RunInfo.MotorSpeed * 20 / 91);
+					}
+					else if((CadenceData.Cadence_Data >= 50) && (CadenceData.Cadence_Data < 90))//输出功率与输入力矩成正比
+					{
+						Torque_Temp = (uint16_t)((uint32_t)(MC_TorqueProcess_Param.TorqueApp * Coefficient_GainCal(MC_AssisParam.Gear_TURBO.Gain_K >> 1, MC_AssisParam.Gear_TURBO.Gain_K, MC_AssisParam.Gear_TURBO.TorqueApp_TH, MC_TorqueProcess_Param.TorqueApp)) >> 10);
+						Torque_Temp = (MC_RunInfo.MotorSpeed < 546) ? MC_AssisParam.Gear_TURBO.Upper_Iq 
+																												: ((MC_RunInfo.MotorSpeed < 983) ? Torque_Temp * 216 / (MC_RunInfo.MotorSpeed * 20 / 91) 
+																																												 : Torque_Temp * CadenceData.Cadence_Data * 24 / 10 / (MC_RunInfo.MotorSpeed * 20 / 91));
+					}
+					else//全功率输出
+					{
+						Torque_Temp = MC_AssisParam.Gear_TURBO.Upper_Iq;
+					}						
+					//根据助力增益调节助力比
+					Torque_Temp = Torque_Temp * MC_ConfigParam1.UserAdjParam_TURBO.Assist_K_GAIN / 100;
+					//给定下限
+					Torque_Temp = (Torque_Temp < MC_AssisParam.Gear_TURBO.Lower_Iq) ? MC_AssisParam.Gear_TURBO.Lower_Iq : Torque_Temp;
+					//给定上限
+					Torque_Temp = (Torque_Temp > MC_AssisParam.Gear_TURBO.Upper_Iq) ? MC_AssisParam.Gear_TURBO.Upper_Iq : Torque_Temp;
+					//限流参数设置
 					CurrentLimitSet = (uint32_t)(MC_AssisParam.Gear_TURBO.CurrentMax_K * MC_ConfigParam1.CurrentLimit * 1000 >> 17) * MC_CadenceLimit_K;
 					CurrentLimitPresent = MC_DataSet_Linear_Process(CurrentLimitSet, CurrentLimitPresent, 5 ,1);
+					PID_IMax.hLower_Limit_Output = -(MC_AssisParam.Gear_TURBO.Upper_Iq);   //Lower Limit for Output limitation
+					PID_IMax.hUpper_Limit_Output = 0; //Upper Limit for Output limitation
+					PID_IMax.wLower_Limit_Integral = -(MC_AssisParam.Gear_TURBO.Upper_Iq << 10); // 放大1024
+					PID_IMax.wUpper_Limit_Integral = 0; // 放大1024
 					break;
 				}
-				default:
+				case MC_GearSt_SMART:
 				{
-					CurrentLimitSet = (uint32_t)(MC_AssisParam.Gear_ECO.CurrentMax_K * MC_ConfigParam1.CurrentLimit * 1000 >> 17) * 100;
+					//控制输入给定加速斜率
+					if(MC_ConfigParam1.UserAdjParam_SMART.StarModel_GAIN <= 90)
+					{
+						TorqueAccStep = MC_AssisParam.Gear_SMART.AccCnt - 1;
+					}
+					else if(MC_ConfigParam1.UserAdjParam_SMART.StarModel_GAIN >= 110)
+					{
+						TorqueAccStep = MC_AssisParam.Gear_SMART.AccCnt + 1;
+					}
+					else
+					{	
+						TorqueAccStep = MC_AssisParam.Gear_SMART.AccCnt;
+					}
+					TorqueAccStep = (TorqueAccStep <= 0) ? 1 : TorqueAccStep;
+					//控制输入给定减速斜率
+					TorqueDecStep = MC_AssisParam.Gear_SMART.DecCnt;
+					//调节电机输出功率
+					if(CadenceData.Cadence_Data < 50)//输出功率与输入力矩成正比，等效于踏频采用固定值50rpm
+					{
+						Torque_Temp = (uint32_t)(MC_TorqueProcess_Param.TorqueApp * MC_TorqueProcess_Param.TorqueApp) / (MC_AssisParam.Gear_SMART.TorqueApp_TH);
+						Torque_Temp = (MC_RunInfo.MotorSpeed < 546) ? MC_AssisParam.Gear_SMART.Upper_Iq 
+																												: Torque_Temp * 120 / (MC_RunInfo.MotorSpeed * 20 / 91);
+					}
+					else if((CadenceData.Cadence_Data >= 50) && (CadenceData.Cadence_Data < 90))//输出功率与输入力矩成正比
+					{
+						Torque_Temp = (uint32_t)(MC_TorqueProcess_Param.TorqueApp * MC_TorqueProcess_Param.TorqueApp) / (MC_AssisParam.Gear_SMART.TorqueApp_TH);
+						Torque_Temp = (MC_RunInfo.MotorSpeed < 546) ? MC_AssisParam.Gear_SMART.Upper_Iq 
+																												: ((MC_RunInfo.MotorSpeed < 983) ? Torque_Temp * 216 / (MC_RunInfo.MotorSpeed * 20 / 91) 
+																																												 : Torque_Temp * CadenceData.Cadence_Data * 24 / 10 / (MC_RunInfo.MotorSpeed * 20 / 91));
+					}
+					else//全功率输出
+					{
+						Torque_Temp = MC_AssisParam.Gear_SMART.Upper_Iq;
+					}	
+					//根据助力增益调节助力比
+					Torque_Temp = Torque_Temp * MC_ConfigParam1.UserAdjParam_SMART.Assist_K_GAIN / 100;
+					//给定下限
+					Torque_Temp = (Torque_Temp < MC_AssisParam.Gear_SMART.Lower_Iq) ? MC_AssisParam.Gear_SMART.Lower_Iq : Torque_Temp;
+					//给定上限
+					Torque_Temp = (Torque_Temp > MC_AssisParam.Gear_SMART.Upper_Iq) ? MC_AssisParam.Gear_SMART.Upper_Iq : Torque_Temp;
+					//限流参数设置
+					CurrentLimitSet = (uint32_t)(MC_AssisParam.Gear_SMART.CurrentMax_K * MC_ConfigParam1.CurrentLimit * 1000 >> 17) * MC_CadenceLimit_K;
 					CurrentLimitPresent = MC_DataSet_Linear_Process(CurrentLimitSet, CurrentLimitPresent, 5 ,1);
-				  break;
+					PID_IMax.hLower_Limit_Output = -(MC_AssisParam.Gear_SMART.Upper_Iq);   //Lower Limit for Output limitation
+					PID_IMax.hUpper_Limit_Output = 0; //Upper Limit for Output limitation
+					PID_IMax.wLower_Limit_Integral = -(MC_AssisParam.Gear_SMART.Upper_Iq << 10); // 放大1024
+					PID_IMax.wUpper_Limit_Integral = 0; // 放大1024
+					break;
+				}
+				default: 
+				{
+					TorqueAccStep = 0;
+					TorqueDecStep = 0;
+					Torque_Temp = 0;
+					break;
+				}
+			}	
+		}
+		
+		//随车速调节助力比
+		Torque_Temp = (uint16_t)((uint32_t)(Torque_Temp * Function_Linear_3Stage(MC_ConfigParam1.SpeedLimit * 10, 0, MC_ConfigParam1.SpeedLimit * 10, 52, MC_SpeedSensorData.Speed_Data)) >> 10);
+			
+    //助力输出		
+		MC_TorqueProcess_Param.TorqueRef = Torque_Temp;
+		if(MC_TorqueProcess_Param.TorqueRef <= 0)
+		{
+			MC_TorqueProcess_Param.TorqueRef = 0;
+		}
+				
+		//升降速曲线计算
+		if( MC_SpeedSensorData.Speed_Data > (MC_ConfigParam1.SpeedLimit * 10) ) //限速处理
+		{
+			if((MC_TorqueProcess_Param.TorqueRef - MC_TorqueProcess_Param.TorqueRefEnd) > 2)
+			{
+				MC_TorqueProcess_Param.TorqueRefEnd += 1;
+			}
+			else if((MC_TorqueProcess_Param.TorqueRef - MC_TorqueProcess_Param.TorqueRefEnd) < (- 1))
+			{
+				MC_TorqueProcess_Param.TorqueRefEnd -= 10; 
+			}
+		}
+		else if( (Bike_Attitude.UpWardSlope_flag == TRUE)&&(MC_SpeedSensorData.Speed_Data < 100))  //上坡处理			  
+		{
+			if((MC_TorqueProcess_Param.TorqueRef - MC_TorqueProcess_Param.TorqueRefEnd) > 2)
+			{
+				MC_TorqueProcess_Param.TorqueRefEnd += TorqueAccStep;
+			}
+			else if((MC_TorqueProcess_Param.TorqueRef - MC_TorqueProcess_Param.TorqueRefEnd) < (- 1))
+			{
+				TorqueRefEndUpdateCount++;			
+				if(TorqueRefEndUpdateCount >=3)
+				{
+					TorqueRefEndUpdateCount = 0;
+					MC_TorqueProcess_Param.TorqueRefEnd -= TorqueDecStep;
+				}
+			}		
+		}	
+		
+    #if SOFT_SATRT		
+    else if(SoftStartFlag == SET)  //启动处理
+		{
+			if(MC_ConfigParam1.StarModel == MC_StarMode_DYNAMIC)  //强劲模式，无延迟
+			{
+			  SoftStartDelayTimeCount = 0;
+				SoftStartFlag = RESET;
+			}
+			else
+			{
+				if(MC_ConfigParam1.StarModel == MC_StarMode_SOFT)   //柔和模式，延迟300ms
+				{
+					SoftStartDelayTime = 300;      //启动处理延时300ms
+					SoftStartAcc = 30;             //30ms递增0.1倍
+				}
+				else                                                //正常模式，延迟100ms
+				{
+					SoftStartDelayTime = 100;      //启动处理延时100ms
+					SoftStartAcc = 10;             //10ms递增0.1倍
+				}
+				SoftStartDelayTimeCount++;
+				if(SoftStartDelayTimeCount <= SoftStartDelayTime) // 缓启动过程,按照0.1倍率逐步增加加减速斜率
+				{  
+					if((MC_TorqueProcess_Param.TorqueRef - MC_TorqueProcess_Param.TorqueRefEnd) > 2)
+					{
+						if((SoftStartDelayTimeCount % (10 - SoftStartDelayTimeCount / SoftStartAcc))  == 0)
+						{
+							MC_TorqueProcess_Param.TorqueRefEnd += TorqueAccStep;
+						}
+					}
+					else if((MC_TorqueProcess_Param.TorqueRef - MC_TorqueProcess_Param.TorqueRefEnd) < (- 1))
+					{
+						MC_TorqueProcess_Param.TorqueRefEnd -= TorqueDecStep;
+					}
+				}
+				else
+				{
+					SoftStartDelayTimeCount = 0;
+					SoftStartFlag = RESET;
 				}
 			}
-			SpdMotorByIdc = PID_Regulator(CurrentLimitPresent / 100, (MC_RunInfo.BusCurrent >> 7), &PID_ConstantPower);
+		}	
+    #endif
+		
+		else //正常骑行
+		{
+			if((MC_TorqueProcess_Param.TorqueRef - MC_TorqueProcess_Param.TorqueRefEnd) > 2)
+			{
+				MC_TorqueProcess_Param.TorqueRefEnd += TorqueAccStep;
+			}
+			else if((MC_TorqueProcess_Param.TorqueRef - MC_TorqueProcess_Param.TorqueRefEnd) < (- 1))
+			{
+				MC_TorqueProcess_Param.TorqueRefEnd -= TorqueDecStep;
+			}
 		}
-	  TorQueBySpd += SpdMotorByIdc;
-		//限速处理
-		TorQueBySpd = (uint16_t)((uint32_t)(TorQueBySpd * Function_Linear_3Stage(0, 0, MC_ConfigParam1.SpeedLimit * 10, 68, MC_RunInfo.BikeSpeed)) >> 10);
-		if(MC_RunInfo.BikeSpeed > MC_ConfigParam1.SpeedLimit * 10 + 22)
+		MC_TorqueProcess_Param.TorqueRefEnd = (MC_TorqueProcess_Param.TorqueRefEnd < 6) ? 6 : MC_TorqueProcess_Param.TorqueRefEnd;
+		
+		//限速点处理
+		if( MC_SpeedSensorData.Speed_Data > (MC_ConfigParam1.SpeedLimit * 10 + 22) ) //限速值 + 2.2
 		{
-			MC_CadenceProcess_Param.MotorSpeedSetBegin = 0;
+			MC_TorqueProcess_Param.MotorStopLock_Flag = SET;
+			MC_TorqueProcess_Param.TorqueRefEnd = 0;
+			//停机处理
 			MC_MotorStop(&MC_StarFlag);
 		}
+		#if 0  //低于限速点启动电机
+		else if(MC_RunInfo.BikeSpeed < ((MC_ConfigParam1.SpeedLimit) * 10))
+		{
+		  MC_MotorStar(&MC_StarFlag);
+		}
+		#elif 1  //低于断电点即启动电机
 		else
 		{
-			//电机启动
-			MC_MotorStar(&MC_StarFlag);
-		}	
+		  MC_MotorStar(&MC_StarFlag);
+		}
+		#endif
 	}
 	
 	#if 1
@@ -856,15 +1168,19 @@ MC_CalParam_Struct_t MC_AssistRunMode_Cadence_Process(MC_CadenceResult_Struct_t
 	uint16_t K_ByTemperature_Result = 1024;
 	#endif
 	
-	Ref_Speed_Temp = ((int32_t)TorQueBySpd * K_ByVoltage_Result) >> 10;
-	Ref_Speed_Temp = ((int32_t)Ref_Speed_Temp * K_ByTemperature_Result) >> 10;
+  //限流计算
+  IqRefByInPower =  PID_Regulator(CurrentLimitPresent / 100, (MC_RunInfo.BusCurrent >> 7), &PID_IMax);
 	
-	p_MC_CalParam.Ref_Speed = (int16_t)(Ref_Speed_Temp);
+	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;
+	
+	p_MC_CalParam.Ref_Torque = (int16_t)Torque_Ref_Temp;
 	p_MC_CalParam.Foc_Flag = SET;
 	p_MC_CalParam.AssistRunMode = MC_AssistRunMode_CADENCE;
 	
 	return (p_MC_CalParam);
-	
+
 }
 
 //力矩模式处理
@@ -1059,11 +1375,11 @@ MC_CalParam_Struct_t MC_AssistRunMode_Torque_Process(MC_CadenceResult_Struct_t C
 		if(IsEnterGasMode == SET)
 		{
 		  Torque_Temp = MC_TorqueProcess_Param.TorqueApp;
-			TorqueAccStep = 5;
+			TorqueAccStep = 3;
 			TorqueDecStep = 7;
 			//给定上限
 		  Torque_Temp = (Torque_Temp > MC_AssisParam.Gear_TURBO.Upper_Iq) ? MC_AssisParam.Gear_TURBO.Upper_Iq : Torque_Temp;
-			CurrentLimitSet = (uint32_t)(MC_AssisParam.Gear_TURBO.CurrentMax_K * MC_ConfigParam1.CurrentLimit * 1000 >> 17) * MC_CadenceLimit_K;
+			CurrentLimitSet = (uint32_t)(MC_AssisParam.Gear_TURBO.CurrentMax_K * MC_ConfigParam1.CurrentLimit * 1000 >> 17) * 100;
 			CurrentLimitPresent = MC_DataSet_Linear_Process(CurrentLimitSet, CurrentLimitPresent, 5 ,1);
 			PID_IMax.hLower_Limit_Output = -(MC_AssisParam.Gear_TURBO.Upper_Iq);   //Lower Limit for Output limitation
 			PID_IMax.hUpper_Limit_Output = 0; //Upper Limit for Output limitation

User/Src/tim.c

@@ -438,12 +438,12 @@ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
 		  	//꽝옘令�땍
 				switch(MC_CalParam.AssistRunMode)
 				{
-				  case MC_AssistRunMode_TORQUE: case MC_AssistRunMode_GAS: //제앤친駕
+				  case MC_AssistRunMode_TORQUE: case MC_AssistRunMode_GAS: case MC_AssistRunMode_CADENCE: //제앤친駕
 					{
 					  FOC_Model(MC_CalParam.Ref_Torque, MC_RunInfo.MotorSpeed, MC_HallSensorData.SVM_Angle);
 						break;
 					}
-					case MC_AssistRunMode_WALK: case MC_AssistRunMode_CADENCE://醵똑친駕
+					case MC_AssistRunMode_WALK: //醵똑친駕
 					{
   				  FOC_Model(MC_CalParam.Ref_Speed, MC_RunInfo.MotorSpeed, MC_HallSensorData.SVM_Angle);
 						break;

User/Src/var.c

@@ -489,7 +489,7 @@ void Var_Init(void)
 		
 	//MC版本信息初始化，Mode和SN从EEPROM读取
   strncpy(MC_VerInfo.HW_Version, (char*)"QD007G.         ", 16);
-	strncpy(MC_VerInfo.FW_Version, (char*)"V2r1r5_20201201.", 16);
+	strncpy(MC_VerInfo.FW_Version, (char*)"V2r1r5_20201202.", 16);
 	strncpy(Firmware_Special, (char*)"TC033001-MS2001-V0r1.           ", 32);
 		
 	//电机型号

修改说明.txt

@@ -356,6 +356,16 @@ V2.1.5_20200903
 2、优化速度传感器滤波，去掉较大值，并在停机时清空滤波数组，解决第一圈信号有随机值问题；
 3、调整踏频模式的控制方法，目前存在起步抖动、限速点停机等问题。
 
+2.1.5_20201202 TC033001A_V0.1
+1、限流强制改为16A；
+2、踏频模式还原为以前的力矩控制方式；
+3、指拨模式去掉低踏频限流。
+
+
+
+
+
+