Procházet zdrojové kódy

V3.2.1_202009016
1、优化相电流有效值计算函数;
2、调整母线电压计算的系数,减小误差;
3、续航数据的初始化和根据母线电压计算的初始电量更改为开机2s后执行,并增加根据BMS通讯正常是否正常来确定使用电压估算容量还是采用电池运行信息的剩余容量;
4、根据踏频计算车速时,增加踩踏方向的判断;
5、增加低压保护、推行限速、推行转速三个参数的设定和查询,并修改相关的处理;
6、调整Pegasi Plus的部分PID参数;
7、调整缺相检测的判断阈值,降低无判断的概率;
8、修改指拨模式的处理,不同档位调整最高的输出转速,调整速比更新的判断条件,并优化开机时存在初始车速时,wheelSpeedPre和
DbSpdMotorPre不更新的问题;
9、还原缓启动的处理,更改逻辑,强劲模式时无缓启动,正常模式时延时100ms,柔和模式时延时300ms;
10、限速点超过2.2km/h关闭助力;
11、母线电流和相电流校零出现故障时,增加日志的存储;
12、PA0作为ETR计数接口,应该配置为GPIO_MODE_INPUT;
13、调整Pegasi Plus的助力比;
14、为兼容国产MCU,修改微故障寄存器检测函数;
15、版本号:V3.2.1_202009016。

dail.zhou před 5 roky
rodič
revize
e2efa06e33

+ 1 - 1
Core/Inc/adc.h

@@ -120,7 +120,7 @@ extern uint16_t uw_current_offset;//ĸ
 
 extern void ADC_Start(void);
 extern void ADC_SensorData_Filt(uint16_t* p_ADC1_Result_Filt, uint16_t* p_ADC2_Result_Filt);
-extern void PhaseCurrent_CalRMSValue(uint16_t* ADC2_Filt, ADC_3ShuntCurrent_Struct_t* PhaseCurrent_RMS);
+extern void PhaseCurrent_CalRMSValue(ADC_3ShuntCurrent_Struct_t* ADC_3ShuntCurrent, ADC_3ShuntCurrent_Struct_t* PhaseCurrent_RMS);
 /* USER CODE END Prototypes */
 
 #ifdef __cplusplus

+ 40 - 21
Core/Src/adc.c

@@ -420,7 +420,7 @@ void HAL_ADCEx_InjectedConvCpltCallback(ADC_HandleTypeDef* hadc)
 	ADC_3ShuntCurrent.uw_phase_c = (int16_t)(ADC_3ShuntCurrent_OffSet.uw_phase_c_offset - ADC2_Result[ADC2_RANK_CURRENT_C]);
 	
 	///计算三相电流有效值
-	PhaseCurrent_CalRMSValue(ADC2_Result, &ADC_3ShuntCurrent_RMSValue);
+	PhaseCurrent_CalRMSValue(&ADC_3ShuntCurrent, &ADC_3ShuntCurrent_RMSValue);
 	
 	ADC2_ConvCpmplete_Flag = SET;
 }
@@ -460,8 +460,8 @@ void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
 	}
 	
 	//更新母线电压 
-	BusVoltageFltSum += ((ADC1_Result[ADC1_RANK_VIN] << 10) - BusVoltageFltSum) >> 8;
-	MC_RunInfo.BusVoltage = (uint32_t)((BusVoltageFltSum >> 10) * 18507) >> 10;//3300 * 1256 / (4095 * 56)
+	BusVoltageFltSum += ((ADC1_Result[ADC1_RANK_VIN] << 10) - BusVoltageFltSum) >> 9;
+	MC_RunInfo.BusVoltage = (uint32_t)((BusVoltageFltSum >> 10) * 18382) >> 10;//3300 * 1047 / (4095 * 47)
 	MC_RunInfo.BusVoltage += (MC_RunInfo.BusCurrent >> 7) * 26; //根据母线电流和估算的线阻进行补偿, 补偿电阻 0.2 * 128 = 25.6
 	
 	//更新绕组温度
@@ -556,7 +556,26 @@ void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
 	}
 	
 	#if 1 //采用原始采集值
-	ADC_SensorData.TorqueSensor = Temp_32;
+	  #if 1 //正常运行
+	  ADC_SensorData.TorqueSensor = Temp_32;
+	  #else //用于寿命测试,模拟输入力矩
+	  if(HAL_GetTick() < 5000)
+		{
+			Temp_32 = 0;
+		}
+		else
+		{
+			static uint32_t WaveTime_Zero = 0;
+			static uint32_t Time_Enter = 0;
+			if((HAL_GetTick() - Time_Enter) > 10)
+			{
+				WaveTime_Zero = HAL_GetTick();
+			}
+			Time_Enter = HAL_GetTick();
+			Temp_32  = TriangleWaveGenerate(WaveTime_Zero, 250, 500 ,1500);  
+		}
+		ADC_SensorData.TorqueSensor = Temp_32;
+	  #endif
 	#else  //采用滤波值
 	static int32_t TorqueFltSum = 0;
 	TorqueFltSum += ((Temp_32 << 10) - TorqueFltSum) >> 8;
@@ -609,50 +628,50 @@ void ADC_SensorData_Filt(uint16_t* p_ADC1_Result_Filt, uint16_t* p_ADC2_Result_F
 }
 
 //相电流有效值计算,有效值 = 最大值 * 0.707,运行频率15K
-void PhaseCurrent_CalRMSValue(uint16_t* ADC2_Result, ADC_3ShuntCurrent_Struct_t* PhaseCurrent_RMS)
+void PhaseCurrent_CalRMSValue(ADC_3ShuntCurrent_Struct_t* ADC_3ShuntCurrent, ADC_3ShuntCurrent_Struct_t* PhaseCurrent_RMS)
 {
-  static uint16_t	PhaseCurrentA_Max = 0;
-	static uint16_t PhaseCurrentB_Max = 0;
-	static uint16_t PhaseCurrentC_Max = 0;
-	static uint16_t Count = 0;
+  static int16_t	PhaseCurrentA_Max = 0;
+	static int16_t PhaseCurrentB_Max = 0;
+	static int16_t PhaseCurrentC_Max = 0;
+	static int16_t Count = 0;
 	int16_t DataTemp;
 	static int32_t PhaseCurrentA_FltSum = 0;
 	static int32_t PhaseCurrentB_FltSum = 0;
 	static int32_t PhaseCurrentC_FltSum = 0;
 	
 	//计算A相电流峰值
-	if(PhaseCurrentA_Max < ADC2_Result[ADC2_RANK_CURRENT_A])
+	if(PhaseCurrentA_Max < ADC_3ShuntCurrent->uw_phase_a)
 	{
-	  PhaseCurrentA_Max = ADC2_Result[ADC2_RANK_CURRENT_A];
+	  PhaseCurrentA_Max = ADC_3ShuntCurrent->uw_phase_a;
 	}
 	//计算B相电流峰值
-	if(PhaseCurrentB_Max < ADC2_Result[ADC2_RANK_CURRENT_B])
+	if(PhaseCurrentB_Max < ADC_3ShuntCurrent->uw_phase_b)
 	{
-	  PhaseCurrentB_Max = ADC2_Result[ADC2_RANK_CURRENT_B];
+	  PhaseCurrentB_Max = ADC_3ShuntCurrent->uw_phase_b;
 	}
 	//计算C相电流峰值
-	if(PhaseCurrentC_Max < ADC2_Result[ADC2_RANK_CURRENT_C])
+	if(PhaseCurrentC_Max < ADC_3ShuntCurrent->uw_phase_c)
 	{
-	  PhaseCurrentC_Max = ADC2_Result[ADC2_RANK_CURRENT_C];
+	  PhaseCurrentC_Max = ADC_3ShuntCurrent->uw_phase_c;
 	}
 	
 	Count++;
 	if(Count >= 500)
 	{
 	  //计算A相电流有效值
-		DataTemp = PhaseCurrentA_Max - ADC_3ShuntCurrent_OffSet.uw_phase_a_offset;
+		DataTemp = PhaseCurrentA_Max;
 		PhaseCurrentA_Max = 0;
-		PhaseCurrentA_FltSum += (((abs(DataTemp) * 724)) - PhaseCurrentA_FltSum) >> 4;
+		PhaseCurrentA_FltSum += (((abs(DataTemp) * 724)) - PhaseCurrentA_FltSum) >> 5;
 		PhaseCurrent_RMS->uw_phase_a = PhaseCurrentA_FltSum >> 10;
 		//计算B相电流有效值
-		DataTemp = PhaseCurrentB_Max - ADC_3ShuntCurrent_OffSet.uw_phase_b_offset;
+		DataTemp = PhaseCurrentB_Max;
 		PhaseCurrentB_Max = 0;
-		PhaseCurrentB_FltSum += (((abs(DataTemp) * 724)) - PhaseCurrentB_FltSum) >> 4;
+		PhaseCurrentB_FltSum += (((abs(DataTemp) * 724)) - PhaseCurrentB_FltSum) >> 5;
 		PhaseCurrent_RMS->uw_phase_b = PhaseCurrentB_FltSum >> 10;
 		//计算C相电流有效值
-		DataTemp = PhaseCurrentC_Max - ADC_3ShuntCurrent_OffSet.uw_phase_c_offset;
+		DataTemp = PhaseCurrentC_Max;
 		PhaseCurrentC_Max = 0;
-		PhaseCurrentC_FltSum += (((abs(DataTemp) * 724)) - PhaseCurrentC_FltSum) >> 4;
+		PhaseCurrentC_FltSum += (((abs(DataTemp) * 724)) - PhaseCurrentC_FltSum) >> 5;
 		PhaseCurrent_RMS->uw_phase_c = PhaseCurrentC_FltSum >> 10;
 		
 		Count = 0;

+ 21 - 7
Core/Src/main.c

@@ -182,9 +182,6 @@ int main(void)
 	
 	//MC控制初始化
 	MC_Init();//339ms
-
-	//续航里程计算变量初始化
-	RD_RemainDis_Init(MC_ConfigParam1.WheelSize + MC_ConfigParam1.WheelSizeAdj, (uint32_t)((ADC1_Result[ADC1_RANK_VIN] * 18507) >> 10) / 10, MC_MotorParam.Rate_Voltage);
 	
 	//检查电机是否授权
 	#if 0	
@@ -201,7 +198,7 @@ int main(void)
 		MC_DeviceCheck(&PBU_CheckInfo, &MC_ErrorCode);
 		#endif
 		
-		#if 1 //校验仪表
+		#if 1 //校验仪表
 		MC_DeviceCheck(&HMI_CheckInfo, &MC_ErrorCode);
 		#endif
 	#endif
@@ -245,7 +242,14 @@ int main(void)
 			}
 			else
 			{
-				SpeedCal_ByCadence(MC_RunInfo.Cadence, MC_ConfigParam1.TeethNum_F, MC_ConfigParam1.TeethNum_B, MC_ConfigParam1.WheelSize + MC_ConfigParam1.WheelSizeAdj, &MC_RunInfo.BikeSpeed);
+				if(MC_RunInfo.CadenceDir != MC_Cadence_Forward) //脚踏向后或停止时,采用电机转速
+				{
+					SpeedCal_ByCadence(MC_RunInfo.MotorSpeed / 11, &MC_SpeedSensorData.Speed_Data, MC_ConfigParam1.TeethNum_F, MC_ConfigParam1.TeethNum_B, MC_ConfigParam1.WheelSize + MC_ConfigParam1.WheelSizeAdj, &MC_RunInfo.BikeSpeed);			
+				}
+				else //脚踏向前时,取最高值
+				{
+					SpeedCal_ByCadence((MC_RunInfo.MotorSpeed / 11 > MC_RunInfo.Cadence) ?  MC_RunInfo.MotorSpeed / 11 : MC_RunInfo.Cadence, &MC_SpeedSensorData.Speed_Data, MC_ConfigParam1.TeethNum_F, MC_ConfigParam1.TeethNum_B, MC_ConfigParam1.WheelSize + MC_ConfigParam1.WheelSizeAdj, &MC_RunInfo.BikeSpeed);			
+				}
 			}
 			
 			//检测变速信号
@@ -258,8 +262,18 @@ int main(void)
 			LightDriver_Process(MC_ControlCode.LightSwitch);
 			
 			//续航里程计算
-			RD_CalculateRemainDis(MC_SpeedSensorData.WheelTurnCount, BMS_RunInfo.RC, BMS_RunInfo.SOC, MC_RunInfo.BusCurrent);
-			RD_SaveAndUpdateInfo(MC_ControlCode.GearSt, MC_CalParam.AssistRunMode);
+			if(HAL_GetTick() > 2000)
+			{
+			  static uint8_t RD_RemainDis_InitFinished = 0x00;
+				if(RD_RemainDis_InitFinished == 0x00)
+				{
+					RD_RemainDis_InitFinished = 0x01;
+					//续航里程计算变量初始化
+					RD_RemainDis_Init(MC_ConfigParam1.WheelSize + MC_ConfigParam1.WheelSizeAdj, IsComOK_BMS.IsOK_Flag, MC_RunInfo.BusVoltage / 10, MC_MotorParam.Rate_Voltage, BMS_RunInfo.RC);	
+				}
+				RD_CalculateRemainDis(MC_SpeedSensorData.WheelTurnCount, BMS_RunInfo.RC, BMS_RunInfo.SOC, MC_RunInfo.BusCurrent);
+				RD_SaveAndUpdateInfo(MC_ControlCode.GearSt, MC_CalParam.AssistRunMode);
+			}
 			
 			//更新电机运行信息
 			MC_RunInfo_Update();

binární
MDK-ARM/bin/MC_TTKZ010A_V3.2.1_20200916.bin


binární
MDK-ARM/bin/QD007A_CTL_APP.bin


+ 67 - 29
SelfTestUser/src_middlewares/stm32f1xx_STUperipheralRegisters.c

@@ -13,6 +13,16 @@ uint8_t DMA_Channel_selftest(DMA_Channel_TypeDef* DMA);
 uint8_t ADC_register_selftest(ADC_TypeDef* ADCx);
 uint8_t TIM_register_selftest(TIM_TypeDef* TIMx);
 
+void STU_delay_us(uint16_t time)
+{    
+   uint16_t i=0;  
+   while(time--)
+   {
+      i=7;  //72MHZ主频,1us
+      while(i--) ;    
+   }
+}
+
 uint8_t STU_PeripheralRegistersTest(void)
 {
 	//uint8_t result;
@@ -104,37 +114,63 @@ uint8_t GPIO_register_selftest(GPIO_TypeDef* GPIOx)
 	//GPIO_tmp.BRR = GPIOx->BRR;      //write only
 	//GPIO_tmp.LCKR = GPIOx->LCKR;    //lock register,don't test
 	
-	//////////CRL //////////////	
-	GPIOx->CRL=TEST_DATA_32B_0X55;
-	//GPIOx->CRL=0x55555554;
-	val=GPIOx->CRL;
-	if(val!=TEST_DATA_32B_0X55)
+	if(GPIOx != GPIOD)
 	{
-		return  (0);
+		//////////CRL //////////////	
+		GPIOx->CRL=TEST_DATA_32B_0X55;
+		//GPIOx->CRL=0x55555554;
+		val=GPIOx->CRL;
+		if(val!=TEST_DATA_32B_0X55)
+		{
+			return  (0);
+		}
+					
+		GPIOx->CRL=TEST_DATA_32B_0XAA;
+		val=GPIOx->CRL;
+		if(val!=TEST_DATA_32B_0XAA)
+					return  (0);	
+	///////////CRH/////////////////////			
+		GPIOx->CRH=TEST_DATA_32B_0X55;
+		val=GPIOx->CRH;
+		if(val!=TEST_DATA_32B_0X55)
+					return  (0);
+		GPIOx->CRH=TEST_DATA_32B_0XAA;
+		val=GPIOx->CRH;
+		if(val!=TEST_DATA_32B_0XAA)
+					return  (0);
+	///////////ODR/////////////////////
+		GPIOx->ODR=0x00005555;
+		val=GPIOx->ODR;
+		if((val& 0x0000FFFF)!=0x00005555)
+					return  (0);
+		GPIOx->ODR=0x0000AAAA;
+		val=GPIOx->ODR;
+		if((val& 0x0000FFFF)!=0x0000AAAA)
+					return  (0);	
+	}
+	else//GPIOD寄存器测试
+	{
+		//////////CRL //////////////	
+		GPIOx->CRL=(GPIO_tmp.CRL&0xFFFFF000)|0x00000555;
+		val=GPIOx->CRL;
+		if( (val&0x00000FFF) !=0x00000555 )
+		{
+			return  (0);
+		}				
+		GPIOx->CRL=(GPIO_tmp.CRL&0xFFFFF000)|0x00000AAA;
+		val=GPIOx->CRL;
+		if( (val&0x00000FFF) !=0x00000AAA )
+					return  (0);	
+	///////////ODR/////////////////////
+		GPIOx->ODR=(GPIO_tmp.ODR&0xFFFFFFF8)|0x00000007;
+		val=GPIOx->ODR;
+		if((val& 0x00000007)!=0x00000007)
+					return  (0);
+		GPIOx->ODR=(GPIO_tmp.ODR&0xFFFFFFF8)|0x00000000;
+		val=GPIOx->ODR;
+		if((val& 0x00000007)!=0x00000000)
+					return  (0);	
 	}
-				
-	GPIOx->CRL=TEST_DATA_32B_0XAA;
-	val=GPIOx->CRL;
-	if(val!=TEST_DATA_32B_0XAA)
-				return  (0);	
-///////////CRH/////////////////////			
-	GPIOx->CRH=TEST_DATA_32B_0X55;
-	val=GPIOx->CRH;
-	if(val!=TEST_DATA_32B_0X55)
-				return  (0);
-	GPIOx->CRH=TEST_DATA_32B_0XAA;
-	val=GPIOx->CRH;
-	if(val!=TEST_DATA_32B_0XAA)
-				return  (0);
-///////////ODR/////////////////////
-	GPIOx->ODR=0x00005555;
-	val=GPIOx->ODR;
-	if((val& 0x0000FFFF)!=0x00005555)
-				return  (0);
-	GPIOx->ODR=0x0000AAAA;
-	val=GPIOx->ODR;
-	if((val& 0x0000FFFF)!=0x0000AAAA)
-				return  (0);	
 
 	/*恢复寄存器的复位默认值*/
 	GPIOx->CRL = GPIO_tmp.CRL;
@@ -310,10 +346,12 @@ uint8_t DMA_Channel_selftest(DMA_Channel_TypeDef* DMA_Channelx)
 	//////////CNDTR//////////////
 	DMA_Channelx->CCR = 0x00000000;
 	DMA_Channelx->CNDTR=0x00005555;
+	STU_delay_us(5);
 	val=DMA_Channelx->CNDTR;
 	if(val!=0x00005555)
 				return  (0);
 	DMA_Channelx->CNDTR=0x0000AAAA;
+	STU_delay_us(5);
 	val=DMA_Channelx->CNDTR;
 		if(val!=0x0000AAAA)
 				return  (0);

+ 0 - 3
User/Inc/battery_info.h

@@ -3,11 +3,8 @@
 
 #include "stm32f1xx_hal.h"
 
-#define RD_BATTERY_INFO_TABLE 1  // 0:不使用电池放电数据得到电量;1:使用电池放电数据查表获得电池电量;
 #define BATTERY_TATAL_Q_MAH 13000  //mAh
 
-//extern const uint16_t battery_VoltageQuantity[1054][2] ;
-
 extern const uint16_t battery_VoltageQuantity[1022][2] ;
 
 #endif

+ 2 - 2
User/Inc/remain_distance.h

@@ -49,8 +49,8 @@ typedef struct
 
 extern Remain_Dis_t RemainDis;
 
-extern void RD_RemainDis_Init(uint16_t uwWheelLength, uint16_t BusVoltage, uint8_t DesignVol);
-extern void RD_CalculateRemainDis(uint32_t WheelTurnCnt, uint16_t RemainCap, uint8_t SOC, uint16_t BusCurrent) ;
+extern void RD_RemainDis_Init(uint16_t uwWheelLength, TrueOrFalse_Flag_Struct_t BMS_COM_OK, uint16_t BusVoltage, uint8_t DesignVol, uint16_t BMS_RC);
+extern void RD_CalculateRemainDis(uint32_t WheelTurnCnt, uint16_t RemainCap, uint8_t SOC, uint16_t BusCurrent);
 extern void RD_SaveAndUpdateInfo(MC_GearSt_Struct_t GearSt, MC_AssistRunMode_Struct_t MC_AssistRunMode);
 extern uint8_t Battery_SocCal(uint16_t Voltage, uint16_t Current);
 

+ 1 - 1
User/Inc/speed_sensor.h

@@ -22,5 +22,5 @@ extern uint16_t MC_Speed_Array[10];
 
 extern void SpeedSensor_GPIO_Init(void);
 extern void SpeedSensor_Process(MC_SpeedSensorData_Struct_t* MC_SpeedSensorData, uint16_t* AvgResult, uint8_t WheelSize, uint8_t Poles);
-extern void SpeedCal_ByCadence(uint16_t CadenceData, uint8_t T_Front, uint8_t T_Tail, uint16_t WheelSize, uint16_t* BikeSpeed);
+extern void SpeedCal_ByCadence(uint16_t CadenceData, uint16_t* SpeedData, uint8_t T_Front, uint8_t T_Tail, uint16_t WheelSize, uint16_t* BikeSpeed);
 #endif

+ 1 - 1
User/Inc/torque_sensor.h

@@ -44,7 +44,7 @@ extern TorqueSensor_Param_Struct_t TorqueSensor_3_Param;
 
 extern TorsueSensorFaultStatus_Struct_t TorsueSensorFaultStatus;
 
-extern uint16_t TorqueStartData;
+extern uint16_t TorqueSensorStartData;
 extern TrueOrFalse_Flag_Struct_t IsTorqueOffSetUpdateEnable;
 
 //È«¾Ö±äÁ¿¶¨Òå

+ 10 - 8
User/Inc/var.h

@@ -84,7 +84,7 @@ typedef union
 }MC_ErrorCode_Struct_t;
 
 //在线检测结果,占用空间1byte
-typedef union 
+typedef union ONLINE_STATUS
 {
 struct
 	{
@@ -116,12 +116,12 @@ typedef struct
 	uint8_t RS[5];
 }BMS_DesignInfo_Struct_t;
 
-typedef enum
+typedef enum STARMODE
 {
   NC = 0U,
-	MC_StarMode_SOFT,
-	MC_StarMode_NORM,
-	MC_StarMode_DYNAMIC,
+	MC_StarMode_SOFT,     //1
+	MC_StarMode_NORM,     //2
+	MC_StarMode_DYNAMIC,  //3
 }MC_StarMode_Struct_t;
 
 typedef struct
@@ -130,7 +130,7 @@ typedef struct
 	uint8_t StarModel_GAIN; //0.01 50-150
 }UserAdjParam_Struct_t;
 
-typedef enum
+typedef enum MC_SUPPORTFLAG
 {
   MC_SUPPORT_ENABLE = (uint8_t)0xAA,  //支持
 	MC_SUPPORT_DISABLE = (uint8_t)0x55  //不支持
@@ -161,7 +161,9 @@ typedef struct
 	uint8_t CadenceStarNum;                      //踏频启动信号个数,地址偏移25
 	MC_SupportFlag_Struct_t No_SpeedSensor_Flag; //0x55-不支持,0x-AA支持,地址偏移26
 	int8_t WheelSizeAdj;                         //周长微调值,地址偏移27
-	uint8_t RS[4];//地址偏移28
+	uint16_t UV_Protect_TH;                      //低压保护值,地址偏移28
+	uint8_t WalkMode_SpeedLimit;                 //推行模式限速,地址偏移30
+	uint8_t WalkMode_MotorSpeedSet;              //推行模式电机转速设置,地址偏移31
 }MC_ConfigParam1_Struct_t;
 
 //用户配置参数2,占用空间32bytes
@@ -361,7 +363,7 @@ typedef struct
 	uint16_t SynC_Clock_Freq;     //地址偏移18
 }MC_TE_SensorData_Struct_t;
 
-typedef enum 
+typedef enum _TO_TE_SENDSTEP
 {
   HANDSHAKE = 0U,
   SENDSENSOR,

+ 14 - 14
User/Src/MC_PID_regulators.c

@@ -38,8 +38,8 @@ const PID_Struct_t PID_Torque_InitStructure_Volans =
   (int32_t)0,          //wPreviousError
   (int32_t)-32768,     //hLower_Limit_Output
   (int32_t)32767,      //hUpper_Limit_Output
-  (int32_t)-33554432,  //wLower_Limit_Integral
-  (int32_t)10240000,   //wUpper_Limit_Integral
+  (int32_t)(-32768 * 1024),  //wLower_Limit_Integral
+  (int32_t)(32767 * 1024),   //wUpper_Limit_Integral
   (int32_t)0           //wIntegral
 };
 
@@ -54,8 +54,8 @@ const PID_Struct_t PID_Flux_InitStructure_Volans =
   (int32_t)0,          //wPreviousError
   (int32_t)-32768,     //hLower_Limit_Output
   (int32_t)32767,      //hUpper_Limit_Output
-  (int32_t)-33554432,  //wLower_Limit_Integral
-  (int32_t)10240000,   //wUpper_Limit_Integral
+  (int32_t)(-32768 * 1024),  //wLower_Limit_Integral
+  (int32_t)(32767 * 1024),   //wUpper_Limit_Integral
   (int32_t)0           //wIntegral
 };
 
@@ -135,8 +135,8 @@ const PID_Struct_t PID_Torque_InitStructure_Volans_Plus =
   (int32_t)0,          //wPreviousError
   (int32_t)-32768,     //hLower_Limit_Output
   (int32_t)32767,      //hUpper_Limit_Output
-  (int32_t)-33554432,  //wLower_Limit_Integral
-  (int32_t)10240000,   //wUpper_Limit_Integral
+  (int32_t)(-32768 * 1024),  //wLower_Limit_Integral
+  (int32_t)(32767 * 1024),   //wUpper_Limit_Integral
   (int32_t)0           //wIntegral
 };
 
@@ -151,8 +151,8 @@ const PID_Struct_t PID_Flux_InitStructure_Volans_Plus =
   (int32_t)0,          //wPreviousError
   (int32_t)-32768,     //hLower_Limit_Output
   (int32_t)32767,      //hUpper_Limit_Output
-  (int32_t)-33554432,  //wLower_Limit_Integral
-  (int32_t)10240000,   //wUpper_Limit_Integral
+  (int32_t)(-32768 * 1024),  //wLower_Limit_Integral
+  (int32_t)(32767 * 1024),   //wUpper_Limit_Integral
   (int32_t)0           //wIntegral
 };
 
@@ -329,8 +329,8 @@ const PID_Struct_t PID_Torque_InitStructure_Pegasi_Plus =
   (int32_t)0,          //wPreviousError
   (int32_t)-32768,     //hLower_Limit_Output
   (int32_t)32767,      //hUpper_Limit_Output
-  (int32_t)-20480000,  //wLower_Limit_Integral
-  (int32_t)20480000,   //wUpper_Limit_Integral
+  (int32_t)(-32768 * 1024),  //wLower_Limit_Integral
+  (int32_t)(32767 * 1024),   //wUpper_Limit_Integral
   (int32_t)0           //wIntegral
 };
 
@@ -345,8 +345,8 @@ const PID_Struct_t PID_Flux_InitStructure_Pegasi_Plus =
   (int32_t)0,          //wPreviousError
   (int32_t)-32768,     //hLower_Limit_Output
   (int32_t)32767,      //hUpper_Limit_Output
-  (int32_t)-20480000,  //wLower_Limit_Integral
-  (int32_t)20480000,   //wUpper_Limit_Integral
+  (int32_t)(-32768 * 1024),  //wLower_Limit_Integral
+  (int32_t)(32767 * 1024),   //wUpper_Limit_Integral
   (int32_t)0           //wIntegral
 };
 
@@ -407,9 +407,9 @@ const PID_Struct_t PID_IMax_Pegasi_Plus =
   (int16_t)0,          //hKd_Gain
   (uint16_t)1024,      //hKd_Divisor
   (int32_t)0,          //wPreviousError
-  (int32_t)-2100,      //hLower_Limit_Output
+  (int32_t)-1050,      //hLower_Limit_Output
   (int32_t)0,          //hUpper_Limit_Output
-  (int32_t)-2150400,   //wLower_Limit_Integral
+  (int32_t)-1075200,   //wLower_Limit_Integral
   (int32_t)0,          //wUpper_Limit_Integral
   (int32_t)0           //wIntegral
 };

+ 3 - 3
User/Src/can_process.c

@@ -561,8 +561,8 @@ void DataProcess(uint16_t ID, uint8_t Mode, uint16_t Cmd, uint8_t* Data)
 				}
 				case 0x2B02://写入力矩传感器启动值
 				{
-				  memcpy((uint8_t*)&TorqueStartData, Data, DataLength);
-					SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_TORQUE_STARDATA, sizeof(TorqueStartData), (uint8_t*)&TorqueStartData);
+				  memcpy((uint8_t*)&TorqueSensorStartData, Data, DataLength);
+					SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_TORQUE_STARDATA, sizeof(TorqueSensorStartData), (uint8_t*)&TorqueSensorStartData);
 					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
 					break;
 				}
@@ -655,7 +655,7 @@ void DataProcess(uint16_t ID, uint8_t Mode, uint16_t Cmd, uint8_t* Data)
 				}
 				case 0x3500://查询启动值
 				{
-				  GetParamFromEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_TORQUE_STARDATA, sizeof(TorqueStartData), Data);
+				  GetParamFromEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_TORQUE_STARDATA, sizeof(TorqueSensorStartData), Data);
 					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xB002, Data);
 					break;
 				}

+ 4 - 4
User/Src/eeprom_24c02.c

@@ -306,9 +306,9 @@ int8_t CopyDataFromEEpprom_24C02(I2C_Handle_Struct_t* I2C_Handle)
 	  GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_AVG_POWER, sizeof(MC_AvgPower_Struct_t), (uint8_t*)&MC_AvgPower.GearSt_ECO);
 	}
 	//读取启动值
-	if(GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_STARDATA, sizeof(TorqueStartData), (uint8_t*)&TorqueStartData) == ACK_FAIL)
+	if(GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_STARDATA, sizeof(TorqueSensorStartData), (uint8_t*)&TorqueSensorStartData) == ACK_FAIL)
 	{
-	  GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_STARDATA, sizeof(TorqueStartData), (uint8_t*)&TorqueStartData);
+	  GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_STARDATA, sizeof(TorqueSensorStartData), (uint8_t*)&TorqueSensorStartData);
 	}
 
 	return ACK_OK;
@@ -396,9 +396,9 @@ void EEPROM_24C02_ParamReset(I2C_Handle_Struct_t* I2C_Handle)
 	  SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_SECRET_KEY, sizeof(Secret_Key), Secret_Key);
 	}
 	//写入力矩传感器启动值
-	if(SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_STARDATA, sizeof(TorqueStartData), (uint8_t*)&TorqueStartData) == ACK_FAIL)
+	if(SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_STARDATA, sizeof(TorqueSensorStartData), (uint8_t*)&TorqueSensorStartData) == ACK_FAIL)
 	{
-	  SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_STARDATA, sizeof(TorqueStartData), (uint8_t*)&TorqueStartData);
+	  SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_STARDATA, sizeof(TorqueSensorStartData), (uint8_t*)&TorqueSensorStartData);
 	}
 }
 

+ 3 - 3
User/Src/fault_check.c

@@ -212,7 +212,7 @@ void MC_Fault_PhaseLine_Process(FlagStatus Foc_Flag, uint16_t BusCurrent, uint16
 	  if((Foc_Flag == SET) && (BusCurrent > 5000) && (MotorSpeed > 500))
 		{
 		  //AÏàµçÁ÷
-			if(abs(Phase_Current.uw_phase_a) < 500)
+			if(abs(Phase_Current.uw_phase_a) < 300)
 			{
 			  if((HAL_GetTick() - TrigTimeCnt_PhaseA) > 3000)
 				{
@@ -234,7 +234,7 @@ void MC_Fault_PhaseLine_Process(FlagStatus Foc_Flag, uint16_t BusCurrent, uint16
 			  TrigTimeCnt_PhaseA = HAL_GetTick();
 			}
 			//BÏàµçÁ÷
-			if(abs(Phase_Current.uw_phase_b) < 500)
+			if(abs(Phase_Current.uw_phase_b) < 300)
 			{
 			  if((HAL_GetTick() - TrigTimeCnt_PhaseB) > 3000)
 				{
@@ -256,7 +256,7 @@ void MC_Fault_PhaseLine_Process(FlagStatus Foc_Flag, uint16_t BusCurrent, uint16
 			  TrigTimeCnt_PhaseB = HAL_GetTick();
 			}
 			//CÏàµçÁ÷
-			if(abs(Phase_Current.uw_phase_c) < 500)
+			if(abs(Phase_Current.uw_phase_c) < 300)
 			{
 			  if((HAL_GetTick() - TrigTimeCnt_PhaseC) > 3000)
 				{

+ 13 - 6
User/Src/math_tools.c

@@ -83,16 +83,23 @@ uint16_t Coefficient_GainCal(uint16_t Min, uint16_t Max, uint16_t Th, uint16_t I
 	uint16_t K;
 	
 	//¼ÆËãK
-	K = (Max - Min) * 1024 / Th;
-	if(InputData > Th)
+	if(Th  == 0)
 	{
-		Result = Max;
-		return Result;
+	  return Max;
 	}
 	else
 	{
-		Result = Min + (K * InputData >> 10);
-		return Result;
+		K = (Max - Min) * 1024 / Th;
+		if(InputData > Th)
+		{
+			Result = Max;
+			return Result;
+		}
+		else
+		{
+			Result = Min + (K * InputData >> 10);
+			return Result;
+		}
 	}
 }
 

+ 183 - 52
User/Src/motor_control.c

@@ -247,29 +247,27 @@ MC_CalParam_Struct_t MC_AssistRunMode_Gas_Process(uint16_t SensorData, MC_GearSt
 
 	/*车轮速度使用原始数据,滤波后的数据有滞后,影响控制回路*/
 	wheelSpeed = (int16_t)MC_SpeedSensorData.Speed_Data;
+	
 	/*实时计算电机转速与车轮速的比值*/
 	SpdMotorDivWheel = 	(uint32_t)(MC_RunInfo.MotorSpeed * 100) / wheelSpeed ;
-	
 	Tmp = SpdMotorDivWheel;
-	SpdMotorDivWheelFlt += ((Tmp<<8) - SpdMotorDivWheelFlt) >> 6;
-	SpdMotorDivWheelFlted = SpdMotorDivWheelFlt>>8;
-	
+	SpdMotorDivWheelFlt += ((Tmp << 8) - SpdMotorDivWheelFlt) >> 6;
+	SpdMotorDivWheelFlted = SpdMotorDivWheelFlt >> 8;
 	
 	/*在电机转速与车轮速比值,与实际速比一致时,更新速比*/
-	if( ( MC_RunInfo.MotorSpeed > 100 ) && ( wheelSpeed > 0 ))
+	if(( MC_RunInfo.MotorSpeed > 100 ) && ( wheelSpeed > 0 ))
 	{
 		/*加速时,更新速比,比较法*/
 		if((wheelSpeed - wheelSpeedPre ) > 5)
 		{
-			if(( MC_RunInfo.MotorSpeed - DbSpdMotorPre )>0)
+			if(( MC_RunInfo.MotorSpeed - DbSpdMotorPre ) > 0)
 			{
 				SpdProportion = SpdMotorDivWheel ;
 			}
 			DbSpdMotorPre = MC_RunInfo.MotorSpeed;
 		}
 		wheelSpeedPre = wheelSpeed;
-		
-		
+			
 		/*求标准差,速比稳定后,更新速比*/
 		/*此处将数据保存到数组中,标准差计算,时间较长,放在主循环进行*/
 		if((SpdProportion_CAL_flag==0) && (MC_CalParam.Ref_Speed > 25))  //电机力矩控制量低于25时,认为是空载,此时不更新速比
@@ -292,24 +290,25 @@ MC_CalParam_Struct_t MC_AssistRunMode_Gas_Process(uint16_t SensorData, MC_GearSt
 			}
 		}
 	}
+	else
+	{
+	  wheelSpeedPre = wheelSpeed;
+		DbSpdMotorPre = MC_RunInfo.MotorSpeed;
+	}
 
 	/*电机最高速度,上位机配置参数*/
 	SpeedMax = MC_MotorParam.Rate_Speed;
 	Tmp = SensorData + 50 ;  //加50偏移量,确保能达到最大值2048
 	Tmp = Tmp > 2048 ? 2048 : Tmp; 
 	
-//			/*调试用,根据车速限速值,换算指拨对应的设定车速*/
-		  dbSpdWheelSet = (Tmp * MC_ConfigParam1.SpeedLimit * 10 )>> 11;	
-	//if(((int16_t)wheelSpeed - (int16_t)dbSpdWheelSet) < 100 )
-		//|| (dbSpdWheelSet < 50  )  )
-//			{
-	
+	/*调试用,根据车速限速值,换算指拨对应的设定车速*/
+	dbSpdWheelSet = (Tmp * MC_ConfigParam1.SpeedLimit * 10 )>> 11;	
+
 	/*电机转速设定,根据指拨大小、车轮限速值和速比,换算*/
 	SpeedSet = ((Tmp * MC_ConfigParam1.SpeedLimit  * SpdProportion) / 10  >> 11);			//(Tmp >> 11) * cd_Speedlimit * ( SpdProportion / 10)
-	//SpeedSet = ((Tmp * cd_MotorSpeed)  >> 11);	//调试
 	
 	//超过限速值,设定电机转速为0
-	if(wheelSpeed > (MC_ConfigParam1.SpeedLimit * 10 + 10))
+	if(wheelSpeed > (MC_ConfigParam1.SpeedLimit * 10 + 20))
 	{
 		SpeedSet = 0;
 	}
@@ -317,29 +316,29 @@ MC_CalParam_Struct_t MC_AssistRunMode_Gas_Process(uint16_t SensorData, MC_GearSt
 	SpeedSet = (SpeedSet > 0) ? SpeedSet : 0;
 	SpeedSet = (SpeedSet < SpeedMax) ? SpeedSet : SpeedMax;
 	
-	
-	switch (GearSt & 0x0F)//Help_mode:bit4: 0-力矩模式,1-踏频模式;低四位表示助力档位
+	//根据档位调整加速度
+	switch (GearSt & 0x0F)
 	{
 		case 0x01:
-			accStep = StepCalc(SpeedMax,1,6500);
+			accStep = StepCalc(SpeedMax, 1, 6500);
 			break;
 		case 0x02:
-			accStep = StepCalc(SpeedMax,1,6000);
+			accStep = StepCalc(SpeedMax, 1, 6000);
 			break;
 		case 0x03:
-			accStep = StepCalc(SpeedMax,1,5500);
+			accStep = StepCalc(SpeedMax, 1, 5500);
 			break;
 		case 0x04:
-			accStep = StepCalc(SpeedMax,1,5000);
+			accStep = StepCalc(SpeedMax, 1, 5000);
 			break;
 		default:
 			/*计算周期1ms, 加减速时间为 5.00s  加减速步进计算*/
-			accStep = StepCalc(SpeedMax,1,5000);
+			accStep = StepCalc(SpeedMax, 1, 5000);
 			break;
 	}
 	
 	/*减速步进*/
-	decStep = StepCalc(SpeedMax,1,1000);
+	decStep = StepCalc(SpeedMax, 1, 1000);
 
 	/* 跟踪启动 */
 	if(MC_CalParam.Foc_Flag  == RESET)			
@@ -353,24 +352,85 @@ MC_CalParam_Struct_t MC_AssistRunMode_Gas_Process(uint16_t SensorData, MC_GearSt
 	}
 		
 	/*速度指令的加减速处理*/
-	SpeedSetReal = accDecProcess(SpeedSet,accStep,decStep,&SpeedSetMiddle);  
+	#if 1  //根据档位设定最高速度
+	
+	switch(GearSt & 0x0F)
+	{
+	  case 0x01:
+			SpeedSetReal = accDecProcess((SpeedSet * 9) >> 4, accStep, decStep, &SpeedSetMiddle);  
+			break;
+		case 0x02:
+			SpeedSetReal = accDecProcess((SpeedSet * 11) >> 4, accStep, decStep, &SpeedSetMiddle);  
+			break;
+		case 0x03:
+			SpeedSetReal = accDecProcess((SpeedSet * 13) >> 4, accStep, decStep, &SpeedSetMiddle);  
+			break;
+		case 0x04:
+			SpeedSetReal = accDecProcess(SpeedSet, accStep, decStep, &SpeedSetMiddle);  
+			break;
+		default:
+			SpeedSetReal = accDecProcess(SpeedSet, accStep, decStep, &SpeedSetMiddle);  
+			break;
+	}
+	
+	#else
+	
+	SpeedSetReal = accDecProcess(SpeedSet, accStep, decStep, &SpeedSetMiddle);  
+	
+	#endif
 
-	/*母线电流限流*/
-	PID_IMax.hLower_Limit_Output= -(MC_AssisParam.Gear_TURBO.Upper_Iq / 2);   //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 / 2) << 10); // 放大1024
-	PID_IMax.wUpper_Limit_Integral = 0; // 放大1024
-	SpdMotorByIdc = PID_Regulator((MC_ConfigParam1.CurrentLimit * 1000) >> 7, MC_RunInfo.BusCurrent >> 7, &PID_ConstantPower); // 母线电流闭环
+	/*限制母线电流*/
+	#if 0 //根据档位设定最大电流,电流环在内环,不稳定
+	
+	static uint16_t CurrentLimitPresent;     //限流实际值,做升降速处理
+	uint16_t CurrentLimitSet;                //限流设置值,不同助力档位更新
+
+	switch(GearSt & 0x0F)
+	{
+	  case 0x01://ECO
+		{
+		  CurrentLimitSet = (uint32_t)(MC_AssisParam.Gear_ECO.CurrentMax_K * MC_ConfigParam1.CurrentLimit * 1000 >> 17);
+			CurrentLimitPresent = MC_DataSet_Linear_Process(CurrentLimitSet, CurrentLimitPresent, 5 ,1);
+			break;
+		}
+		case 0x02://NORM
+		{
+		  CurrentLimitSet = (uint32_t)(MC_AssisParam.Gear_NORM.CurrentMax_K * MC_ConfigParam1.CurrentLimit * 1000 >> 17);
+			CurrentLimitPresent = MC_DataSet_Linear_Process(CurrentLimitSet, CurrentLimitPresent, 5 ,1);
+			break;
+		}
+		case 0x03://SPORT
+		{
+		  CurrentLimitSet = (uint32_t)(MC_AssisParam.Gear_SPORT.CurrentMax_K * MC_ConfigParam1.CurrentLimit * 1000 >> 17);
+			CurrentLimitPresent = MC_DataSet_Linear_Process(CurrentLimitSet, CurrentLimitPresent, 5 ,1);
+			break;
+		}
+		case 0x04://TURBO			
+		{
+		  CurrentLimitSet = (uint32_t)(MC_AssisParam.Gear_TURBO.CurrentMax_K * MC_ConfigParam1.CurrentLimit * 1000 >> 17);
+			CurrentLimitPresent = MC_DataSet_Linear_Process(CurrentLimitSet, CurrentLimitPresent, 5 ,1);
+			break;
+		}
+		default://SMART
+		{
+		  CurrentLimitSet = (uint32_t)(MC_AssisParam.Gear_SMART.CurrentMax_K * MC_ConfigParam1.CurrentLimit * 1000 >> 17);
+			CurrentLimitPresent = MC_DataSet_Linear_Process(CurrentLimitSet, CurrentLimitPresent, 5 ,1);
+			break;
+		}
+	}
+	SpdMotorByIdc = PID_Regulator(CurrentLimitPresent, MC_RunInfo.BusCurrent >> 7, &PID_ConstantPower);
+	
+	#else
+	
+	SpdMotorByIdc = PID_Regulator((MC_ConfigParam1.CurrentLimit * 1000) >> 7, MC_RunInfo.BusCurrent >> 7, &PID_ConstantPower);
+	
+	#endif
 	
 	/* 电机速度闭环 */
-	/*最大力矩为4档的力矩参数*/
+	//最大力矩为4档的力矩参数
 	PID_MotorSpd.hLower_Limit_Output= -(MC_AssisParam.Gear_TURBO.Upper_Iq / 2);
 	PID_MotorSpd.hUpper_Limit_Output= (MC_AssisParam.Gear_TURBO.Upper_Iq / 2);
-//			PID_MotorSpd.wLower_Limit_Integral = -((ContrlParam.Gear_4st.Upper_Iq / 2) << 10); // 放大1024
-//			PID_MotorSpd.wUpper_Limit_Integral = ((ContrlParam.Gear_4st.Upper_Iq / 2) << 10); // 放大1024
-	TorQueBySpd = PID_Regulator(SpeedSetReal,	\
-															MC_RunInfo.MotorSpeed ,   \
-															&PID_MotorSpd); // 电机速度闭环输出
+	TorQueBySpd = PID_Regulator(SpeedSetReal, MC_RunInfo.MotorSpeed, &PID_MotorSpd);
 
 	TorQueBySpd += SpdMotorByIdc;
 	
@@ -394,6 +454,7 @@ MC_CalParam_Struct_t MC_AssistRunMode_Gas_Process(uint16_t SensorData, MC_GearSt
 	
 	uint16_t K_ByVoltage_Result = 1024;
 	uint16_t K_ByTemperature_Result = 1024;
+	
 	#endif
 	
 	//速度环控制量为0时停机,防止电机出现异响
@@ -409,7 +470,7 @@ MC_CalParam_Struct_t MC_AssistRunMode_Gas_Process(uint16_t SensorData, MC_GearSt
 	
 	Ref_Speed_Temp = ((int32_t)TorQueBySpd * K_ByVoltage_Result) >> 10;
 	Ref_Speed_Temp = ((int32_t)Ref_Speed_Temp * K_ByTemperature_Result) >> 10;
-	
+
 	p_MC_CalParam.Ref_Speed = (int16_t)(Ref_Speed_Temp);
 	p_MC_CalParam.Foc_Flag = SET;
 	p_MC_CalParam.AssistRunMode = MC_AssistRunMode_GAS;
@@ -453,20 +514,25 @@ MC_CalParam_Struct_t MC_AssistRunMode_Walk_Process(MC_WorkMode_Struct_t p_MC_Wor
 		SpdMotorByIdc = PID_Regulator((MC_ConfigParam1.CurrentLimit * 1000) >> 7, MC_RunInfo.BusCurrent >> 7, &PID_ConstantPower); // 母线电流闭环
 	}
 	
-	//运行模式,设定转速 = 135rpm
+	//运行模式,设定转速 = 设置值
 	else
 	{
-		if(MC_WalkProcess_Param.MotorSpeedSetBigin < (135 << 5) - 10)
+		uint8_t WalkMode_MotorSpeedSet = 0;
+		
+		//新增配置项,兼容旧电机
+		WalkMode_MotorSpeedSet = (MC_ConfigParam1.WalkMode_MotorSpeedSet == 0) ? 135 : MC_ConfigParam1.WalkMode_MotorSpeedSet;
+		
+		if(MC_WalkProcess_Param.MotorSpeedSetBigin < (WalkMode_MotorSpeedSet << 5) - 10)
 		{
 		  MC_WalkProcess_Param.MotorSpeedSetBigin += 1;
 		}
-		else if(MC_WalkProcess_Param.MotorSpeedSetBigin > (135 << 5) + 10)
+		else if(MC_WalkProcess_Param.MotorSpeedSetBigin > (WalkMode_MotorSpeedSet << 5) + 10)
 		{
 		  MC_WalkProcess_Param.MotorSpeedSetBigin -= 1;
 		}
 		else
 		{
-		  MC_WalkProcess_Param.MotorSpeedSetBigin = 135 << 5;
+		  MC_WalkProcess_Param.MotorSpeedSetBigin = WalkMode_MotorSpeedSet << 5;
 		}
 		SpdMotorByIdc = PID_Regulator((MC_ConfigParam1.CurrentLimit * 500) >> 7, MC_RunInfo.BusCurrent >> 7, &PID_ConstantPower); // 母线电流闭环
 	}
@@ -475,11 +541,16 @@ MC_CalParam_Struct_t MC_AssistRunMode_Walk_Process(MC_WorkMode_Struct_t p_MC_Wor
 	TorQueBySpd = PID_Regulator((MC_WalkProcess_Param.MotorSpeedSetBigin >> 5), MC_RunInfo.MotorSpeed, &PID_MotorSpd); // 电机速度闭环输出
 	TorQueBySpd += SpdMotorByIdc;
 	
-	//限制车速低于6km/h
-	if(p_MC_WorkMode != MC_WorkMode_Config) //运行模式,推行限速6km/h
+	//限制车速低于设置值
+	if(p_MC_WorkMode != MC_WorkMode_Config) //运行模式,推行限速
 	{
-	  TorQueBySpd = (uint16_t)((uint32_t)(TorQueBySpd * Function_Linear_3Stage(55, 0, 55, 128, MC_RunInfo.BikeSpeed)) >> 10);
-		if(MC_RunInfo.BikeSpeed > 60)
+		uint8_t WalkMode_SpeedLimit = 0;
+		
+		//新增配置项,兼容旧电机	
+		WalkMode_SpeedLimit = (MC_ConfigParam1.WalkMode_SpeedLimit == 0) ? 60 : MC_ConfigParam1.WalkMode_SpeedLimit;
+		
+	  TorQueBySpd = (uint16_t)((uint32_t)(TorQueBySpd * Function_Linear_3Stage((WalkMode_SpeedLimit - 5), 0, (WalkMode_SpeedLimit - 5), 128, MC_RunInfo.BikeSpeed)) >> 10);
+		if(MC_RunInfo.BikeSpeed > WalkMode_SpeedLimit)
 		{
 			MC_WalkProcess_Param.MotorSpeedSetBigin = 0;
 			MC_MotorStop(&MC_StarFlag);
@@ -583,6 +654,15 @@ MC_CalParam_Struct_t MC_AssistRunMode_Torque_Process(uint16_t SenorData, MC_Gear
 	uint16_t CurrentLimitSet;                //限流设置值,不同助力档位更新
 	
 	static uint8_t TorqueRefEndUpdateCount = 0;
+	
+	#define SOFT_SATRT 1
+	
+	#if SOFT_SATRT
+	static FlagStatus SoftStartFlag = SET;
+	static uint16_t SoftStartDelayTimeCount = 0;
+	uint16_t SoftStartDelayTime = 0;
+	uint16_t SoftStartAcc = 0;
+	#endif
 
 	#if 1
 	
@@ -649,7 +729,7 @@ MC_CalParam_Struct_t MC_AssistRunMode_Torque_Process(uint16_t SenorData, MC_Gear
 	#endif
 		
 	//低力矩停机
-	TorqueStopData = (TorqueStartData < 200) ? 100 : (TorqueStartData >> 1);
+	TorqueStopData = (TorqueSensorStartData < 200) ? 100 : (TorqueSensorStartData >> 1);
 	if(MC_TorqueProcess_Param.TorqueApp >= (TorqueStopData))
 	{
 	  TorqueStopDelayTimeCnt = HAL_GetTick();
@@ -674,11 +754,11 @@ MC_CalParam_Struct_t MC_AssistRunMode_Torque_Process(uint16_t SenorData, MC_Gear
 	//启动值判断
 	if(MC_RunInfo.BikeSpeed > 60) 
 	{
-		TorqueStartData =  (TorqueStartData < 200 ? 150 : (TorqueStartData > 700 ? 525 : ((TorqueStartData * 3) >> 2)));
+		TorqueStartData =  (TorqueSensorStartData < 200 ? 150 : (TorqueSensorStartData > 700 ? 525 : ((TorqueSensorStartData * 3) >> 2)));
 	}
 	else
 	{
-		TorqueStartData =  (TorqueStartData < 200 ? 150 : (TorqueStartData > 700 ? 525 : TorqueStartData));
+		TorqueStartData =  (TorqueSensorStartData < 200 ? 150 : (TorqueSensorStartData > 700 ? 525 : TorqueSensorStartData));
 	}
 	if(MC_TorqueProcess_Param.TorqueApp >= TorqueStartData)
 	{
@@ -701,6 +781,12 @@ MC_CalParam_Struct_t MC_AssistRunMode_Torque_Process(uint16_t SenorData, MC_Gear
 		  MC_TorqueProcess_Param.TorqueRefEnd = 0;
 			//停机处理
 			MC_MotorStop(&MC_StarFlag);
+			
+			#if SOFT_SATRT
+			//缓启动标志置位
+			SoftStartFlag = SET;
+			SoftStartDelayTimeCount = 0;
+			#endif
 		}
 		else
 		{
@@ -939,7 +1025,52 @@ MC_CalParam_Struct_t MC_AssistRunMode_Torque_Process(uint16_t SenorData, MC_Gear
 					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;
+				}
+			}
+		}	
+    #endif
+		
 		else //正常骑行
 		{
 			if((MC_TorqueProcess_Param.TorqueRef - MC_TorqueProcess_Param.TorqueRefEnd) > 2)
@@ -954,7 +1085,7 @@ MC_CalParam_Struct_t MC_AssistRunMode_Torque_Process(uint16_t SenorData, MC_Gear
 		MC_TorqueProcess_Param.TorqueRefEnd = (MC_TorqueProcess_Param.TorqueRefEnd < 6) ? 6 : MC_TorqueProcess_Param.TorqueRefEnd;
 		
 		//限速点处理
-		if( MC_SpeedSensorData.Speed_Data > (MC_ConfigParam1.SpeedLimit * 10 + 20) ) //限速值+2
+		if( MC_SpeedSensorData.Speed_Data > (MC_ConfigParam1.SpeedLimit * 10 + 22) ) //限速值+2.2
 		{
 			MC_TorqueProcess_Param.MotorStopLock_Flag = SET;
 			MC_TorqueProcess_Param.TorqueRefEnd = 0;
@@ -1240,7 +1371,7 @@ void SpdProportion_calculate(void)
 		test_StandardDeviation = (int32_t)(SpdProportion_StandardDeviation );
 		SpdProportion_CAL_flag = 0;
 		/*更新速比*/
-		if(test_StandardDeviation < 20)
+		if(test_StandardDeviation < 30)
 		{
 			SpdProportion = test_SpdProportionAver;
 		}

+ 6 - 6
User/Src/protect_check.c

@@ -11,7 +11,7 @@ FlagStatus MC_Protect_OverCurrentTrig_Flag = RESET;
 
 /******************************局部函数定义******************************/
 //低压保护检测
-void MC_Protect_UnderVoltage_Process(uint16_t BusVoltage, uint8_t DesignVoltage, MC_ErrorCode_Struct_t* p_MC_ErrorCode)
+void MC_Protect_UnderVoltage_Process(uint16_t BusVoltage, uint8_t DesignVoltage, uint16_t UV_TH, MC_ErrorCode_Struct_t* p_MC_ErrorCode)
 {
   static uint32_t uvTimeCnt = 0;
 	static uint32_t uvFaultTimeCnt = 0;
@@ -22,17 +22,17 @@ void MC_Protect_UnderVoltage_Process(uint16_t BusVoltage, uint8_t DesignVoltage,
 	{
 		case 24:
 		{
-			UV_Voltage = 3100 * 7;//低压保护时,电芯电压为3100mV
+			UV_Voltage = UV_TH * 7;//低压保护时,电芯电压为3100mV
 		  break;
 		}
 		case 36:
 		{
-			UV_Voltage = 3100 * 10;//低压保护时,电芯电压为3100mV
+			UV_Voltage = UV_TH * 10;//低压保护时,电芯电压为3100mV
 		  break;
 		}
 		case 48:
 		{
-			UV_Voltage = 3100 * 13;//低压保护时,电芯电压为3100mV
+			UV_Voltage = UV_TH * 13;//低压保护时,电芯电压为3100mV
 		  break;
 		}
 		default:
@@ -393,8 +393,8 @@ void MC_Protect_OverCurrent_Process(FlagStatus* OverCurrentTrigFlag, MC_ErrorCod
 void MC_Protect_Check_Process(void)
 {
 	//低压保护检测
-	MC_Protect_UnderVoltage_Process(MC_RunInfo.BusVoltage, MC_MotorParam.Rate_Voltage, &MC_ErrorCode);
-
+	MC_Protect_UnderVoltage_Process(MC_RunInfo.BusVoltage, MC_MotorParam.Rate_Voltage, ((MC_ConfigParam1.UV_Protect_TH == 0) ? 3100 : MC_ConfigParam1.UV_Protect_TH), &MC_ErrorCode);
+	
 	//过压保护检测
 	MC_Protect_OverVoltage_Process(MC_RunInfo.BusVoltage, MC_MotorParam.Rate_Voltage, &MC_ErrorCode);
 

+ 18 - 16
User/Src/remain_distance.c

@@ -25,7 +25,7 @@
 extern const MC_AvgPower_Struct_t MC_AvgPower_Default;
 
 //续航计算相关参数
-Remain_Dis_t RemainDis;
+Remain_Dis_t RemainDis = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFFFF, 0, 0, FALSE, 0};
 //电池信息
 Battery_Info_t Battery_Info;
 
@@ -52,10 +52,10 @@ static void RD_getQRemainRecord(uint16_t Volgate)
 	BusVoltage = Volgate;
 	
 	//查表读取电池电量
-	num = sizeof(battery_VoltageQuantity)/4;
+	num = sizeof(battery_VoltageQuantity) / 4;
 	batteryTotalQ = battery_VoltageQuantity[num-1][1];
 	batteryRemainQ = batteryTotalQ;
-	for(i=0;i<num;i++)
+	for(i=0; i<num; i++)
 	{
 		if(battery_VoltageQuantity[i][0] <=  BusVoltage)
 		{
@@ -86,33 +86,35 @@ static void RD_getQRemainRecord(uint16_t Volgate)
 *          20181221      V1.2          Damon             modify
 * 
 *******************************************************************************/
-void RD_RemainDis_Init(uint16_t uwWheelLength, uint16_t BusVoltage, uint8_t DesignVol)
+void RD_RemainDis_Init(uint16_t uwWheelLength, TrueOrFalse_Flag_Struct_t BMS_COM_OK, uint16_t BusVoltage, uint8_t DesignVol, uint16_t BMS_RC)
 {
 	Battery_Info.Q_discharged = 0;
 	Battery_Info.Q_remain_real = 0;
 	Battery_Info.Q_remain_record = BATTERY_TATAL_Q_MAH;
 	Battery_Info.Q_remain_real_last = 0;
 	
-#if RD_BATTERY_INFO_TABLE
-	/*配置不带CAN通讯的电池时调用,上电读取电池电压,查表获得剩余电量,放电曲线是按照36V,针对48V或24V做等效转换*/
-       RD_getQRemainRecord(BusVoltage * 36 / DesignVol);
-	RemainDis.IsBMS_ComOK_Flag = FALSE;
-#endif
+	if(BMS_COM_OK == TRUE) //电池通讯正常时,直接获取电池容量
+	{
+	  Battery_Info.Q_remain_real = BMS_RC;
+	}
+	else //电池不含通讯时,根据母线电压估算剩余容量
+	{
+	  RD_getQRemainRecord(BusVoltage * 36 / DesignVol); //放电曲线是按照36V,针对48V或24V做等效转换
+	}
 	
-	RemainDis.acc_period = Q_ADD_TIME_MS;
-	RemainDis.wheel_Count = 0;
+	RemainDis.start = 0;
 	RemainDis.I_motor = 0;
+	RemainDis.acc_period = Q_ADD_TIME_MS;
 	RemainDis.Q_add = 0;
 	RemainDis.wheelLength = uwWheelLength;
-	RemainDis.flag_saveInfo = 0;
-	RemainDis.flag_helpModeChange = 0;
+	RemainDis.wheel_Count = 0;
 	RemainDis.Power_per_km = 0;
 	RemainDis.Power_per_km_average = 0;
 	RemainDis.remainDistance = 0xFFFF;//码表显示---km
-	RemainDis.start = 0;
+	RemainDis.flag_saveInfo = 0;
+	RemainDis.flag_helpModeChange = 0;
 	RemainDis.IsBMS_ComOK_Flag = FALSE;
-	RemainDis.BMS_Com_DelayTimeCnt = HAL_GetTick();	
-	
+	RemainDis.BMS_Com_DelayTimeCnt = HAL_GetTick();		
 }
 
 /******************************************************************************

+ 4 - 3
User/Src/speed_sensor.c

@@ -17,7 +17,7 @@ void SpeedSensor_GPIO_Init(void)
 {
    GPIO_InitTypeDef GPIO_InitStruct;
 
-	__HAL_RCC_GPIOB_CLK_ENABLE();
+	__HAL_RCC_GPIOD_CLK_ENABLE();
 	
   GPIO_InitStruct.Pin = SPEED_SENSOR_Pin;
   GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
@@ -81,7 +81,7 @@ void SpeedSensor_Process(MC_SpeedSensorData_Struct_t* p_MC_SpeedSensorData, uint
 	}
 }
 
-void SpeedCal_ByCadence(uint16_t CadenceData, uint8_t T_Front, uint8_t T_Tail, uint16_t WheelSize, uint16_t* BikeSpeed)
+void SpeedCal_ByCadence(uint16_t CadenceData, uint16_t* SpeedData, uint8_t T_Front, uint8_t T_Tail, uint16_t WheelSize, uint16_t* BikeSpeed)
 {
   static uint32_t PeriodTimeCnt = 0;
 	static uint8_t FltCount = 0;
@@ -90,7 +90,8 @@ void SpeedCal_ByCadence(uint16_t CadenceData, uint8_t T_Front, uint8_t T_Tail, u
 	if((HAL_GetTick() - PeriodTimeCnt) >= 50)
 	{
 	  PeriodTimeCnt = HAL_GetTick();
-		FltSum += ((CadenceData * T_Front / T_Tail * WheelSize * 144) / 10000);//车速 = 踏频 * 2.4 * 前飞齿数 / 后飞齿数 * 60 / 1000 km/h,结果单位0.1km/h
+		*SpeedData = ((CadenceData * T_Front / T_Tail * WheelSize * 144) / 10000);//车速 = 踏频 * 2.4 * 前飞齿数 / 后飞齿数 * 60 / 1000 km/h,结果单位0.1km/h
+		FltSum += *SpeedData;
 		FltCount++;
 		if(FltCount >= 8)
 		{

+ 16 - 0
User/Src/stm32f10x_svpwm_3shunt.c

@@ -2,6 +2,7 @@
 #include "MC_const.h"
 #include "adc.h"
 #include "pwm_driver.h"
+#include "log_save.h"
 
 //全局变量定义
 
@@ -56,6 +57,13 @@ void SVPWM_3ShuntCurrentReadingCalibration(MC_ErrorCode_Struct_t* p_MC_ErrorCode
 	  )
 	{
 	  p_MC_ErrorCode->ERROR_Bit.Fault_Circuit = 1;
+		//记录故障日志
+		MC_ErrorLogSaveInfo.NotesInfo1 = 6;
+		ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
+		IsErrorLogSaveInfoUpdateFlag = TRUE;
+		//存储故障次数
+		MC_RunLog2.Circuit_FaultCnt++;
+		RunLogSaveIndex = 2;
 	}
 	
 	Disable_Pwm_Output();
@@ -98,6 +106,14 @@ void CurrentReadingCalibration(MC_ErrorCode_Struct_t* p_MC_ErrorCode)
 			if((uw_current_offset < 1000) || (uw_current_offset > 3000))
 			{
 			  p_MC_ErrorCode->ERROR_Bit.Fault_Circuit = 1;
+				//记录故障日志
+				MC_ErrorLogSaveInfo.NotesInfo1 = 7;
+				MC_ErrorLogSaveInfo.NotesInfo2 = uw_current_offset;
+				ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
+				IsErrorLogSaveInfoUpdateFlag = TRUE;
+				//存储故障次数
+				MC_RunLog2.Circuit_FaultCnt++;
+				RunLogSaveIndex = 2;
 			}
 			PeriodTimeCnt = HAL_GetTick();
 		}

+ 1 - 1
User/Src/tim.c

@@ -205,7 +205,7 @@ void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* htim_base)
     PA0-WKUP     ------> TIM2_ETR 
     */
     GPIO_InitStruct.Pin = GPIO_PIN_0;
-    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
     GPIO_InitStruct.Pull = GPIO_NOPULL;
     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

+ 1 - 1
User/Src/torque_sensor.c

@@ -12,7 +12,7 @@ TorqueSensor_Param_Struct_t TorqueSensor_3_Param;//
 
 TorsueSensorFaultStatus_Struct_t TorsueSensorFaultStatus;//3个传感器的故障状态
 
-uint16_t TorqueStartData = TORQUE_SENSOR_STARTDATA;//启动值
+uint16_t TorqueSensorStartData = TORQUE_SENSOR_STARTDATA;//启动值
 TrueOrFalse_Flag_Struct_t IsTorqueOffSetUpdateEnable = FALSE;//运行中零点值动态更新标志
 
 /**************************局部函数定义*************************/

+ 33 - 30
User/Src/var.c

@@ -78,7 +78,10 @@ const MC_ConfigParam1_Struct_t MC_ConfigParam1_Default =
 	(uint8_t)1,                                      //速度传感器极数
 	(uint8_t)2,                                      //踏频启动信号个数
 	(MC_SupportFlag_Struct_t)MC_SUPPORT_DISABLE,     //无速度传感器支持,0x55-不支持,0x-AA支持	
-	(int8_t)0                                        //轮胎周长微调值                                        
+	(int8_t)0,                                       //轮胎周长微调值       
+	(uint16_t)3100,                                  //低压保护阈值,单位mV,针对单节电芯的设置值	
+  (uint8_t)60,                                     //推行限速值,单位0.1km/h
+	(uint8_t)135                                     //推行模式电机转速设置值
 };
 
 //MC配置参数2,占用32bytes
@@ -298,7 +301,7 @@ const nGearParam_Struct_t GearParam_Default_ECO_Pegasi =
 	(uint16_t)937,
 	(uint8_t)2,
 	(uint8_t)1,
-	(uint16_t)338
+	(uint16_t)512
 };
 
 //NORM档位助力参数
@@ -310,7 +313,7 @@ const nGearParam_Struct_t GearParam_Default_NORM_Pegasi =
 	(uint16_t)1250,
 	(uint8_t)3,
 	(uint8_t)2,
-	(uint16_t)489
+	(uint16_t)686
 };
 
 //SPORT档位助力参数
@@ -322,7 +325,7 @@ const nGearParam_Struct_t GearParam_Default_SPORT_Pegasi =
 	(uint16_t)1459,
 	(uint8_t)4,
 	(uint8_t)2,
-	(uint16_t)686
+	(uint16_t)870
 };
 
 //TURBO档位助力参数
@@ -353,48 +356,48 @@ const nGearParam_Struct_t GearParam_Default_SMART_Pegasi =
 //ECO档位助力参数
 const nGearParam_Struct_t GearParam_Default_ECO_Pegasi_Plus =
 {
-  (uint16_t)523,
+  (uint16_t)476,
 	(uint16_t)560,
-	(uint16_t)100,
-	(uint16_t)871,
-	(uint8_t)1,
+	(uint16_t)0,
+	(uint16_t)937,
+	(uint8_t)2,
 	(uint8_t)1,
-	(uint16_t)235
+	(uint16_t)512
 };
 
 //NORM档位助力参数
 const nGearParam_Struct_t GearParam_Default_NORM_Pegasi_Plus =
 {
-  (uint16_t)1198,
+  (uint16_t)1142,
 	(uint16_t)700,
-	(uint16_t)100,
-	(uint16_t)1055,
+	(uint16_t)0,
+	(uint16_t)1250,
+	(uint8_t)3,
 	(uint8_t)2,
-	(uint8_t)1,
-	(uint16_t)331
+	(uint16_t)686
 };
 
 //SPORT档位助力参数
 const nGearParam_Struct_t GearParam_Default_SPORT_Pegasi_Plus =
 {
-  (uint16_t)1712,
+  (uint16_t)1903,
 	(uint16_t)840,
-	(uint16_t)100,
-	(uint16_t)1464,
-	(uint8_t)3,
-	(uint8_t)1,
-	(uint16_t)512
+	(uint16_t)0,
+	(uint16_t)1459,
+	(uint8_t)4,
+	(uint8_t)2,
+	(uint16_t)870
 };
 
 //TURBO档位助力参数
 const nGearParam_Struct_t GearParam_Default_TURBO_Pegasi_Plus =
 {
-  (uint16_t)2861,
+  (uint16_t)2857,
 	(uint16_t)980,
-	(uint16_t)100,
+	(uint16_t)0,
 	(uint16_t)2100,
 	(uint8_t)5,
-	(uint8_t)2,
+	(uint8_t)3,
 	(uint16_t)1024
 };
 
@@ -402,11 +405,11 @@ const nGearParam_Struct_t GearParam_Default_TURBO_Pegasi_Plus =
 const nGearParam_Struct_t GearParam_Default_SMART_Pegasi_Plus =
 {
   (uint16_t)0,
-	(uint16_t)1850,
-	(uint16_t)100,
+	(uint16_t)1200,
+	(uint16_t)0,
 	(uint16_t)2100,
 	(uint8_t)4,
-	(uint8_t)1,
+	(uint8_t)2,
 	(uint16_t)1024
 };
 
@@ -426,7 +429,7 @@ void Var_SetToDefaultParam(void)
 	memcpy(Secret_Key, Secret_Key_Default, sizeof(Secret_Key_Default));
 	
 	//启动值设为默认值
-	TorqueStartData = TORQUE_SENSOR_STARTDATA;
+	TorqueSensorStartData = TORQUE_SENSOR_STARTDATA;
 	
   //配置参数1
 	memcpy((uint8_t*)&MC_ConfigParam1.GasCtrlMode_Flag, (uint8_t*)&MC_ConfigParam1_Default.GasCtrlMode_Flag, sizeof(MC_ConfigParam1_Default));
@@ -485,8 +488,8 @@ void Var_Init(void)
 	memcpy((uint8_t*)&PBU_ConfigParam.GearsNum, (uint8_t*)&PBU_ConfigParam_Default.GearsNum, sizeof(PBU_ConfigParam_Struct_t));
 		
 	//MC版本信息初始化,Mode和SN从EEPROM读取
-  strncpy(MC_VerInfo.HW_Version, (char*)"TT_KZ_010C.     ", 16);//TT_KZ_010A
-	strncpy(MC_VerInfo.FW_Version, (char*)"V3r2r0_20200708", 16);
+  strncpy(MC_VerInfo.HW_Version, (char*)"TT_KZ_010D.     ", 16);//TT_KZ_010A
+	strncpy(MC_VerInfo.FW_Version, (char*)"V3r2r1_20200916", 16);
 	
 	//电机型号
 	strncpy(MC_VerInfo.Mode, (char*)"PG8000 & PSX000.", 16);
@@ -497,7 +500,7 @@ void Var_Init(void)
 	//生产信息
 	strncpy(MC_MacInfo.Manufacturer, (char*)"MOTINOVA", 8);  //生产信息
 	strncpy(MC_MacInfo.MacAddr, (char*)"WUHAN.  ", 8);
-	strncpy(MC_MacInfo.MacDate, (char*)"20200114", 8);
+	strncpy(MC_MacInfo.MacDate, (char*)"20200901", 8);
 
 	//MCU ID读取
 	memcpy((uint8_t*)MC_CheckInfo.MAC_ID, (uint8_t*)(0x1FFFF7E8), 12);

+ 16 - 2
修改说明.txt

@@ -301,8 +301,22 @@ V3.2.0_20200708 Dail
 1、开启Flash读保护;
 2、版本号:V3.2.0_20200708
 
-
-
+V3.2.1_202009016
+1、优化相电流有效值计算函数;
+2、调整母线电压计算的系数,减小误差;
+3、续航数据的初始化和根据母线电压计算的初始电量更改为开机2s后执行,并增加根据BMS通讯正常是否正常来确定使用电压估算容量还是采用电池运行信息的剩余容量;
+4、根据踏频计算车速时,增加踩踏方向的判断;
+5、增加低压保护、推行限速、推行转速三个参数的设定和查询,并修改相关的处理;
+6、调整Pegasi Plus的部分PID参数;
+7、调整缺相检测的判断阈值,降低无判断的概率;
+8、修改指拨模式的处理,不同档位调整最高的输出转速,调整速比更新的判断条件,并优化开机时存在初始车速时,wheelSpeedPre和DbSpdMotorPre不更新的问题;
+9、还原缓启动的处理,更改逻辑,强劲模式时无缓启动,正常模式时延时100ms,柔和模式时延时300ms;
+10、限速点超过2.2km/h关闭助力;
+11、母线电流和相电流校零出现故障时,增加日志的存储;
+12、PA0作为ETR计数接口,应该配置为GPIO_MODE_INPUT;
+13、调整Pegasi Plus的助力比;
+14、为兼容国产MCU,修改微故障寄存器检测函数;
+15、版本号:V3.2.1_202009016。