1、更改踏频传感器型号，方向和频率由传感器输出，根据硬件版本识别踏频传感器型号，调用不同的踏频计算函数；

2、增加平均车速、最大车速、卡路里计算，发送骑行历史时一起发送，平均功耗预留位用于存储最大车速和骑行消耗总能量；
3、模拟I2C延时参数由50改为20，延迟一次时间由3.7us缩短为1.5us，读一次启动值时间由2.84ms缩短为1.42ms；
4、取消骑行3km或骑行10min自动存储数据，取消温度最值更新时自动存储数据，统一用10min定时存储MC_RunLog1、MC_RideLog、MC_AvgPower。

Core/Src/main.c

@@ -302,7 +302,7 @@ int main(void)
 			MC_DebugInfo_Update();
 			
 			//计算运行总时间
-			MC_RunTime_Cal(&MC_RunLog1.RunTime);
+			MC_RunTime_Cal();
 			
 			//温度历史数据记录
 			MC_TemperatureLogProcess();
@@ -332,6 +332,9 @@ int main(void)
 				MC_PowerOffBkp.Trip_Km = MC_RideLog.TRIP_Km;
 				MC_PowerOffBkp.Trip_Time = MC_RideLog.TRIP_Time;
 				MC_PowerOffBkp.Run_Time = MC_RunLog1.RunTime;
+				MC_PowerOffBkp.Log_ODO_Km = MC_RunLog1.ODO_Km;
+				MC_PowerOffBkp.Log_ODO_Time = MC_RunLog1.ODO_Time;
+				MC_PowerOffBkp.PedalPoweSum = MC_AvgPower.PedalPowerSum;
 				SaveDataToEEPROM_Flash(EEPROM_FLASH_ADDR_POWEROFF_BKP, (uint8_t*)&MC_PowerOffBkp.ODO_Km, 40);//写入掉电临时保存数据，写入前该区域需擦除为0xFF才能操作成功
 				SaveDataToEEPROM_Flash(EEPROM_FLASH_ADDR_POWEROFF_BKP_FLAG, (uint8_t*)"FLAG", 4); //掉电存储的数据标志更新
 				PowerDown_SaveFlag = FALSE;

User/Inc/I2C_Analog.h

@@ -3,7 +3,7 @@
 
 #include "stm32f1xx_hal.h"
 
-#define DLY_US 50 
+#define DLY_US 20 
 
 typedef struct
 {

User/Inc/cadence_sensor.h

@@ -42,6 +42,11 @@ extern uint16_t MC_Cadence_Array[10];
 
 extern uint8_t Cadence_ReadHallState(void);
 extern void CadenceSensor_GPIO_Init(void);
-extern void CadenceSensor_Process(MC_CadenceResult_Struct_t* p_MC_CadenceResult, uint16_t StopDelayTime, uint8_t StarCount, TrueOrFalse_Flag_Struct_t UpSlopeFlag);
+
+//适用双通道输出传感器，根据相位判断方向
+extern void CadenceSensor_Process1(MC_CadenceResult_Struct_t* p_MC_CadenceResult, uint16_t StopDelayTime, uint8_t StarCount, TrueOrFalse_Flag_Struct_t UpSlopeFlag);
+
+//适用频率和方向输出传感器，
+extern void CadenceSensor_Process2(MC_CadenceResult_Struct_t* p_MC_CadenceResult, uint16_t StopDelayTime, uint8_t StarCount, TrueOrFalse_Flag_Struct_t UpSlopeFlag);
 
 #endif

User/Inc/fault_check.h

@@ -7,7 +7,8 @@
 #include "motor_control.h"
 
 extern void MC_Fault_HallSensor_Process(MC_HallSensorStatus_Struct_t HallSensorStatus, MC_ErrorCode_Struct_t* p_MC_ErrorCode);
-extern void MC_Fault_CadenceSensor_Process(uint16_t Torque, uint16_t BikeSpeed, MC_ErrorCode_Struct_t* p_MC_ErrorCode);
+extern void MC_Fault_CadenceSensor_Process1(uint16_t Torque, uint16_t BikeSpeed, MC_ErrorCode_Struct_t* p_MC_ErrorCode);
+extern void MC_Fault_CadenceSensor_Process2(uint16_t Torque, uint16_t BikeSpeed, MC_ErrorCode_Struct_t* p_MC_ErrorCode);
 extern void MC_Fault_Check_Process(void);
 
 #endif

User/Inc/tasks.h

@@ -20,7 +20,7 @@ extern uint8_t MC_CadenceLimit_Cal(uint8_t Cadence, uint16_t Current, uint8_t T_
 extern void PowerOff_Process(TrueOrFalse_Flag_Struct_t ReturnEnable);
 extern void MC_CanRxCheck_Process(MC_SupportFlag_Struct_t NoPBU_Flag, MC_SupportFlag_Struct_t NoHMI_Flag, MC_WorkMode_Struct_t WorkMode, MC_GearSt_Struct_t* GearSt);
 extern void MC_UartRxCheck_Process(void);
-extern void MC_RunTime_Cal(uint32_t* p_Runtime);
+extern void MC_RunTime_Cal(void);
 extern void MC_DeviceCheck(Device_CheckInfo_Struct_t* p_Device, MC_ErrorCode_Struct_t* p_ErrorCode);
 extern void Cal_SyncClockFreq(uint16_t* Result);
 extern void MC_TemperatureLogProcess(void);
@@ -28,4 +28,5 @@ extern void MC_TE_SensorScan(MC_TE_SensorData_Struct_t* p_MC_TE_SensorData);
 extern void NoPBUMode_Ini( void );
 extern void BikeRatioCal_Process(uint16_t MotorSpeed, uint16_t Cadence, uint16_t BikeSpeed, Bike_RatioCal_Struct_t* p_Bike_RatioCal);
 extern void Device_Handshake_Process(void);
+
 #endif

User/Inc/var.h

@@ -339,6 +339,16 @@ typedef struct
 	uint32_t TRIP_Time;  //TRIP时间，地址偏移12
 }MC_RideLog_Struct_t;
 
+//MC骑行信息，占用空间16bytes
+typedef struct
+{
+  uint16_t SpeedAvg;    //平均车速
+	uint16_t SpeedMax;    //最高车速
+	uint32_t Cal_Trip;    //卡路里Trip
+	uint16_t Cal_Once;    //卡路里Once
+	uint8_t RS[6];
+}MC_RideInfo_Struct_t;
+
 //MC版本信息，占用空间64bytes
 typedef struct
 {
@@ -367,7 +377,8 @@ typedef struct
 	uint32_t Run_Time;
 	uint32_t Log_ODO_Km;
 	uint32_t Log_ODO_Time;
-	uint32_t RS[3];
+	uint32_t PedalPoweSum;
+	uint32_t RS[2];
 }MC_PowerOffBkp_Struct_t;
 
 //电池运行状态，占用空间1bytes
@@ -515,7 +526,8 @@ typedef struct
 	uint16_t GearSt_SPORT;  //SPORT平均功耗，单位mAh/km
 	uint16_t GearSt_TURBO;  //TURBO平均功耗，单位mAh/km
 	uint16_t GearSt_SMART;  //SMART平均功耗，单位mAh/km
-	uint16_t Rs[3];
+	uint16_t SpeedMax;      //预留最高车速
+	uint32_t PedalPowerSum; //人力累计功率，单位Wmin，	
 }MC_AvgPower_Struct_t;
 
 //传动比计算参数
@@ -577,6 +589,7 @@ extern ComOK_Check_Struct_t IsComOK_HMI;
 extern ComOK_Check_Struct_t IsComOK_BMS;
 extern MC_AttitudeAngle_Struct_t MC_AttitudeAngle;
 extern MC_RideLog_Struct_t MC_RideLog;
+extern MC_RideInfo_Struct_t MC_RideInfo;
 extern MC_AvgPower_Struct_t MC_AvgPower;
 extern MCU_Manufacturter_Struct_t MCUManufacturer;                         
 extern uint16_t SpeedRatio;
@@ -584,6 +597,8 @@ extern uint16_t HardwareVersion_AD;
 extern TrueOrFalse_Flag_Struct_t VersionIdentifyFinishedFlag;
 extern TrueOrFalse_Flag_Struct_t PowerDown_SaveFlag;
 extern Bike_RatioCal_Struct_t Bike_RatioCalParam;
+extern int32_t PedalPowerFltSum;
+
 /**************************全局变量声明End***************************/
 
 /**************************全局函数声明Begin*************************/

User/Src/cadence_sensor.c

@@ -46,7 +46,7 @@ void CadenceSensor_GPIO_Init(void)
 }
 
 //踏频传感器检测处理
-void CadenceSensor_Process(MC_CadenceResult_Struct_t* p_MC_CadenceResult, uint16_t StopDelayTime, uint8_t StarCount, TrueOrFalse_Flag_Struct_t UpSlopeFlag)
+void CadenceSensor_Process1(MC_CadenceResult_Struct_t* p_MC_CadenceResult, uint16_t StopDelayTime, uint8_t StarCount, TrueOrFalse_Flag_Struct_t UpSlopeFlag)
 {
 	static MC_CadenceSensorStatus_Struct_t MC_CadenceSensorStatus;
 	static TrueOrFalse_Flag_Struct_t IsFirstEnterFalg = TRUE;
@@ -181,6 +181,122 @@ void CadenceSensor_Process(MC_CadenceResult_Struct_t* p_MC_CadenceResult, uint16
 	MC_CadenceSensorStatus.HallGropuStatus_Old = MC_CadenceSensorStatus.HallGropuStatus;
 }
 
+void CadenceSensor_Process2(MC_CadenceResult_Struct_t* p_MC_CadenceResult, uint16_t StopDelayTime, uint8_t StarCount, TrueOrFalse_Flag_Struct_t UpSlopeFlag)
+{
+  static MC_CadenceSensorStatus_Struct_t MC_CadenceSensorStatus;
+	static TrueOrFalse_Flag_Struct_t IsFirstEnterFalg = TRUE;
+	uint8_t CadenceHallStatus1, CadenceHallStatus2, CadenceHallStatus3;
+	
+	//读取霍尔信号
+	CadenceHallStatus1 = Cadence_ReadHallState();
+	CadenceHallStatus2 = Cadence_ReadHallState();
+	CadenceHallStatus3 = Cadence_ReadHallState();	
+	//连续采集三次霍尔，三次状态都一致才更新霍尔状态，防us级干扰
+	if( (CadenceHallStatus1==CadenceHallStatus2)&&(CadenceHallStatus2==CadenceHallStatus3) ) 
+	{
+		MC_CadenceSensorStatus.HallGropuStatus = CadenceHallStatus3;
+	}
+	if(IsFirstEnterFalg == TRUE)
+	{
+	  MC_CadenceSensorStatus.HallGropuStatus_Old = MC_CadenceSensorStatus.HallGropuStatus;
+		IsFirstEnterFalg = FALSE;
+	}
+	
+	//正反转判断
+	if(MC_CadenceSensorStatus.HallGropuStatus != MC_CadenceSensorStatus.HallGropuStatus_Old)
+	{
+	  static uint16_t BackwordDelayCnt1 = 0;
+		if((MC_CadenceSensorStatus.HallGropuStatus & 0x02) == 0x02) //正转
+		{
+			p_MC_CadenceResult->Cadence_Dir = MC_Cadence_Forward;
+			BackwordDelayCnt1 = 0;
+		}
+		else //反转
+		{
+			BackwordDelayCnt1++;
+			if(BackwordDelayCnt1 >= 4)//检测到连续4次反向脉冲则判断为反转，约4/120*360=12度
+			{
+				p_MC_CadenceResult->Cadence_Dir = MC_Cadence_Backward;
+				BackwordDelayCnt1 = 0;
+			}
+		}
+	}
+  
+  //踏频计算与停止判断
+	static uint32_t CadenceCalTimeCnt = 0;       //用于计算蹋频值
+	static int32_t Cadence_ActiveFlt = 0;
+	static uint16_t CadenceTemp;	
+	static uint8_t CadenceStarFlagCnt = 0;       //用于判断启动
+	static uint32_t CadenceStopJudgeTimeCnt = 0; //用于判断停止	
+	uint8_t CadenceStartThresholdValue = 2;  //踏频启动阈值，霍尔信号数，6度/个
+	
+	if((MC_CadenceSensorStatus.HallGropuStatus & 0x01) != (MC_CadenceSensorStatus.HallGropuStatus_Old & 0x01))
+	{	  
+	  //踏频计算及滤波处理
+	  CadenceTemp	= 500 / (HAL_GetTick() - CadenceCalTimeCnt);//转1圈有120个信号，根据两个信号之间的时间计算踏频值rpm
+		CadenceCalTimeCnt = HAL_GetTick();
+		
+		/*上坡时，启动阈值为1*/
+		if(UpSlopeFlag == TRUE)
+		{
+			CadenceStartThresholdValue =  1;
+		}
+		else
+		{
+			CadenceStartThresholdValue =  StarCount;
+		}
+		
+		//起步判断
+		if(p_MC_CadenceResult->Cadence_Dir == MC_Cadence_Forward)
+		{
+		  CadenceStarFlagCnt++;
+			if(CadenceStarFlagCnt >= CadenceStartThresholdValue)
+			{
+			  p_MC_CadenceResult->IsStopFlag = FALSE;
+			}
+		}
+		else
+		{
+		  p_MC_CadenceResult->IsStopFlag = TRUE;
+		}
+		
+		/*根据踏频的信号，对力矩进行滤波处理*/
+		p_MC_CadenceResult->torqueByCadence = torqueFilteredThroughCadence(ADC_SensorData.TorqueSensor,1);
+		
+		//更新停机计时数值
+		CadenceStopJudgeTimeCnt = HAL_GetTick();
+		
+		p_MC_CadenceResult->TrigCount++;
+	}
+	Cadence_ActiveFlt += (((int32_t)CadenceTemp << 10) - Cadence_ActiveFlt) >> 8;
+	p_MC_CadenceResult->Cadence_Data = (uint8_t)(Cadence_ActiveFlt >> 10);
+	
+	//停机判断
+	/*
+  n < 20rpm, k = 3
+  n > 40rpm, k = 1
+  20rpm <= n <= 40rpm, k = -0.1 * n + 5
+  */  
+  uint16_t k = 100;
+  k = (CadenceTemp < 20) ? 300 : ((CadenceTemp > 40) ? 100 : (500 - CadenceTemp * 10));
+  StopDelayTime = k * StopDelayTime / 100;
+	if((HAL_GetTick() - CadenceStopJudgeTimeCnt) > StopDelayTime)
+	{
+		p_MC_CadenceResult->IsStopFlag = TRUE;
+		p_MC_CadenceResult->Cadence_Dir = MC_Cadence_Stop;
+		p_MC_CadenceResult->Cadence_Data = 0;
+		CadenceTemp = 0;
+		Cadence_ActiveFlt = 0;
+		CadenceStarFlagCnt =0;
+		
+		/*清零相关变量*/
+		p_MC_CadenceResult->torqueByCadence = torqueFilteredThroughCadence(ADC_SensorData.TorqueSensor,0);		
+	}
+	
+	MC_CadenceSensorStatus.HallGropuStatus_Old = MC_CadenceSensorStatus.HallGropuStatus;
+	
+}
+
 uint16_t torqueFilteredThroughCadence(uint16_t torque_temp, uint8_t modeFlag)
 {
 	#define T_FIFO_LENGTH 30                       //每个信号6度，30为180度 

User/Src/can_process.c

@@ -223,12 +223,13 @@ void DataProcess(uint16_t ID, uint8_t Mode, uint16_t Cmd, uint8_t* Data)
 				}
 				case 0x3500://OBC查询骑行历史
 				{
-				  	SendData(ID_MC_BC, MODE_REPORT, 0x1510, (uint8_t*)&MC_RideLog.ODO_Km);
+				  SendData(ID_MC_BC, MODE_REPORT, 0x1510, (uint8_t*)&MC_RideLog.ODO_Km);
+					SendData(ID_MC_BC, MODE_REPORT, 0x1A10, (uint8_t*)&MC_RideInfo.SpeedAvg);
 					break;
 				}
 				case 0x3605://OBC清除TRIP信息
 				{
-			  		if(strncmp("CLEAR", (char*)Data, DataLength) == 0)
+			  	  if(strncmp("CLEAR", (char*)Data, DataLength) == 0)
 					{
 					  	MC_RideLog.TRIP_Km = 0;
 						MC_RideLog.TRIP_Time = 0;
@@ -246,6 +247,9 @@ void DataProcess(uint16_t ID, uint8_t Mode, uint16_t Cmd, uint8_t* Data)
 						SendData(ID_MC_TO_PBU, MODE_REPORT, 0x5303, (uint8_t*)"ACK");
 						MC_RunInfo.Ride_Km = 0;
 						MC_RunInfo.Ride_Time = 0;
+						MC_AvgPower.SpeedMax = 0;	
+						SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_AVG_POWER, sizeof(MC_AvgPower_Struct_t), (uint8_t*)&MC_AvgPower.GearSt_ECO);
+						PedalPowerFltSum = 0;
 					}
 					break;
 				}
@@ -444,6 +448,7 @@ void DataProcess(uint16_t ID, uint8_t Mode, uint16_t Cmd, uint8_t* Data)
 			  case 0x3400://查询电机骑行历史信息
 				{
 					SendData(ID_MC_BC, MODE_REPORT, 0x1510, (uint8_t*)&MC_RideLog.ODO_Km);
+					SendData(ID_MC_BC, MODE_REPORT, 0x1A10, (uint8_t*)&MC_RideInfo.SpeedAvg);
 					break;
 				}
 				case 0x3505://清除TRIP信息
@@ -466,6 +471,9 @@ void DataProcess(uint16_t ID, uint8_t Mode, uint16_t Cmd, uint8_t* Data)
 						SendData(ID_MC_TO_HMI, MODE_REPORT, 0x7403, (uint8_t*)"ACK");
 						MC_RunInfo.Ride_Km = 0;
 						MC_RunInfo.Ride_Time = 0;
+						MC_AvgPower.SpeedMax = 0;	
+            SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_AVG_POWER, sizeof(MC_AvgPower_Struct_t), (uint8_t*)&MC_AvgPower.GearSt_ECO);						
+						PedalPowerFltSum = 0;
 					}
 				}
 				default:break;
@@ -762,6 +770,7 @@ void DataProcess(uint16_t ID, uint8_t Mode, uint16_t Cmd, uint8_t* Data)
 				case 0x2E00://查询骑行历史信息
 				{
 					SendData(ID_MC_BC, MODE_REPORT, 0x1510, (uint8_t*)&MC_RideLog.ODO_Km);
+					SendData(ID_MC_BC, MODE_REPORT, 0x1A10, (uint8_t*)&MC_RideInfo.SpeedAvg);
 					break;
 				}
 				case 0x2F00://读取姿态传感器数值

User/Src/eeprom_24c02.c

@@ -437,9 +437,12 @@ int8_t SavePowerOffBakData(I2C_Handle_Struct_t* I2C_Handle, TrueOrFalse_Flag_Str
 		MC_RideLog.TRIP_Time = MC_PowerOffBkp.Trip_Time;
 		MC_RunLog1.ODO_Km = MC_PowerOffBkp.Log_ODO_Km;
 		MC_RunLog1.ODO_Time = MC_PowerOffBkp.Log_ODO_Time;
+		MC_AvgPower.PedalPowerSum = MC_PowerOffBkp.PedalPoweSum;
 		if(SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_RIDE_LOG, sizeof(MC_RideLog_Struct_t), (uint8_t*)&MC_RideLog.ODO_Km) == ACK_FAIL)
 		{
-			SaveParamToEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_RIDE_LOG, sizeof(MC_RideLog_Struct_t), (uint8_t*)&MC_RideLog.ODO_Km);
+			SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt);
+			SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RIDE_LOG, sizeof(MC_RideLog_Struct_t), (uint8_t*)&MC_RideLog.ODO_Km);
+			SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_AVG_POWER, sizeof(MC_AvgPower_Struct_t), (uint8_t*)&MC_AvgPower.GearSt_ECO);
 		}
 	}
 	

User/Src/fault_check.c

@@ -1012,7 +1012,7 @@ void MC_Fault_HallSensor_Process(MC_HallSensorStatus_Struct_t HallSensorStatus,
 }
 
 //踏频传感器故障检测
-void MC_Fault_CadenceSensor_Process(uint16_t Torque, uint16_t BikeSpeed, MC_ErrorCode_Struct_t* p_MC_ErrorCode)
+void MC_Fault_CadenceSensor_Process1(uint16_t Torque, uint16_t BikeSpeed, MC_ErrorCode_Struct_t* p_MC_ErrorCode)
 {
 	static uint8_t Hall_1_Trg = 0; //霍尔1信号变化标志
 	static uint8_t Hall_1_Cont = 0;//霍尔1状态
@@ -1074,7 +1074,7 @@ void MC_Fault_CadenceSensor_Process(uint16_t Torque, uint16_t BikeSpeed, MC_Erro
 			//判断霍尔2
 			if(Hall_2_Trg == 0)
 			{
-			  if((HAL_GetTick() - Hall_2_Fault_TrigTimeCnt) > 5000)
+			  if((HAL_GetTick() - Hall_2_Fault_TrigTimeCnt) > 10000)
 				{
 				  p_MC_ErrorCode->ERROR_Bit.Fault_CadenceSensor = 1;
 					//记录故障日志
@@ -1095,7 +1095,7 @@ void MC_Fault_CadenceSensor_Process(uint16_t Torque, uint16_t BikeSpeed, MC_Erro
       //判断霍尔1和霍尔2黏连
       if(Hall_1_2_EQA_Flag == 0) 
 			{
-			  if((HAL_GetTick() - Hall_1_2_EQA_TrigTimeCnt) > 5000)
+			  if((HAL_GetTick() - Hall_1_2_EQA_TrigTimeCnt) > 10000)
 				{
 				  p_MC_ErrorCode->ERROR_Bit.Fault_CadenceSensor = 1;
 					//记录故障日志
@@ -1123,6 +1123,59 @@ void MC_Fault_CadenceSensor_Process(uint16_t Torque, uint16_t BikeSpeed, MC_Erro
 	}
 }
 
+void MC_Fault_CadenceSensor_Process2(uint16_t Torque, uint16_t BikeSpeed, MC_ErrorCode_Struct_t* p_MC_ErrorCode)
+{
+	static uint8_t Hall_2_Trg = 0; //霍尔2信号变化标志
+	static uint8_t Hall_2_Cont = 0;//霍尔2状态
+	static uint32_t Hall_2_Fault_TrigTimeCnt = 0;
+	static uint8_t Hall_2_State;
+		
+	Hall_2_State = HAL_GPIO_ReadPin(CADENCE_2_GPIO_Port, CADENCE_2_Pin);
+	
+	//更新霍尔2信号变化状态，相同为0，不同为1
+	Hall_2_Trg = Hall_2_State ^ Hall_2_Cont;
+	Hall_2_Cont = Hall_2_State;
+	
+	if(HAL_GetTick() < 1000)
+	{
+		Hall_2_Fault_TrigTimeCnt = HAL_GetTick();
+		return;
+	}
+	
+	if(p_MC_ErrorCode->ERROR_Bit.Fault_CadenceSensor == 0)
+	{		
+		//两个霍尔传感器分别检测是否存在开路或短路 
+		if((Torque > 1200) && (BikeSpeed > 70))
+		{
+			//判断霍尔2
+			if(Hall_2_Trg == 0)
+			{
+			  if((HAL_GetTick() - Hall_2_Fault_TrigTimeCnt) > 10000)
+				{
+				  p_MC_ErrorCode->ERROR_Bit.Fault_CadenceSensor = 1;
+					//记录故障日志
+					MC_ErrorLogSaveInfo.NotesInfo1 = 2;
+		  		ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
+			  	IsErrorLogSaveInfoUpdateFlag = TRUE;
+					//存储故障次数
+          MC_RunLog2.CadenceSensor_FaultCnt++;
+					RunLogSaveIndex = 2;
+					
+					return;
+				}
+			}
+			else
+			{
+			  Hall_2_Fault_TrigTimeCnt = HAL_GetTick();
+			}		
+		}
+		else
+		{
+		  Hall_2_Fault_TrigTimeCnt = HAL_GetTick();
+		}
+	}
+}
+
 //故障检测
 void MC_Fault_Check_Process(void)
 {	

User/Src/hardware_check.c

@@ -68,7 +68,7 @@ void GetHardware_Versin(uint16_t VolaVal)
 						#else
 						Error
 						#endif
-						MC_VerInfo.HW_Version[7] =Hardware_VersionTable[Count];
+						MC_VerInfo.HW_Version[7] = Hardware_VersionTable[Count];
 						VersionIdentifyFinishedFlag = TRUE;
 						return ;
 					}

User/Src/tasks.c

@@ -46,12 +46,24 @@ void HAL_SYSTICK_Callback(void)
 	}
 
 	//踏频传感器采集及计算
-	CadenceSensor_Process(&MC_CadenceResult, MC_ConfigParam1.StopTime, (MC_ConfigParam1.CadenceStarNum == 0) ? 2 : MC_ConfigParam1.CadenceStarNum, FALSE);
+	if(VersionIdentifyFinishedFlag == TRUE)
+	{
+		if(MC_VerInfo.HW_Version[7] < 'C')
+	    CadenceSensor_Process1(&MC_CadenceResult, MC_ConfigParam1.StopTime, (MC_ConfigParam1.CadenceStarNum == 0) ? 2 : MC_ConfigParam1.CadenceStarNum, FALSE);
+		else
+			CadenceSensor_Process2(&MC_CadenceResult, MC_ConfigParam1.StopTime, (MC_ConfigParam1.CadenceStarNum == 0) ? 2 : MC_ConfigParam1.CadenceStarNum, FALSE);
+	}	
 	
 	//踏频传感器故障检测
 	if(MC_WorkMode == MC_WorkMode_Run)
 	{
-	  MC_Fault_CadenceSensor_Process(ADC_SensorData.TorqueSensor, MC_RunInfo.BikeSpeed, &MC_ErrorCode);
+	  if(VersionIdentifyFinishedFlag == TRUE)
+		{
+			if(MC_VerInfo.HW_Version[7] < 'C')
+		    MC_Fault_CadenceSensor_Process1(ADC_SensorData.TorqueSensor, MC_RunInfo.BikeSpeed, &MC_ErrorCode);		
+			else
+				MC_Fault_CadenceSensor_Process2(ADC_SensorData.TorqueSensor, MC_RunInfo.BikeSpeed, &MC_ErrorCode);
+		}	
 	}
 	
 	//根据电机工作模式(MC_WorkMode)、力矩传感器和指拨AD值(ADC_SensorData)、控制档位(MC_ControlCode.GearSt)计算控制FOC输入值(MC_CalParam)
@@ -173,6 +185,9 @@ void MC_RunInfo_Update(void)
 		//计算力矩值
 		MC_RunInfo.Torque = ADC_SensorData.TorqueSensor / 28;
 		
+		//踩踏功率计算		
+		PedalPowerFltSum += (((int32_t)(MC_RunInfo.Cadence * MC_RunInfo.Torque * 107) - PedalPowerFltSum) >> 4);  //P = n * T / 9.55		
+		
 		//当前助力档位
 		MC_RunInfo.GearSt = MC_ControlCode.GearSt;
 		
@@ -239,7 +254,7 @@ void MC_RunInfo_Update(void)
 			MC_RunInfo.Ride_Km++;
 			MC_RunInfo.ODO_Km = MC_RideLog.ODO_Km / 10;
 			
-			#if 1 //自动存储骑行里程
+			#if 0 //自动存储骑行里程
 			static uint8_t SavePeriodCount = 0;
 			SavePeriodCount++;
 			if(SavePeriodCount >= 30)//存储周期为3km
@@ -276,23 +291,50 @@ void MC_RunInfo_Update(void)
 			//更新骑行历史信息中骑行时间
 	  	MC_RideLog.ODO_Time++;
 			MC_RunLog1.ODO_Time++;
+			MC_RideLog.TRIP_Time++;
 			#if 0 //时间是否自动归零
-			MC_RideLog.ODO_Time = (MC_RideLog.ODO_Time > 599999) ? 0 : MC_RideLog.ODO_Time;   //超过9999h59min，清零
-			MC_RideLog.TRIP_Time = (MC_RideLog.TRIP_Time > 599999) ? 0 : MC_RideLog.TRIP_Time;//超过9999h59min，清零
+			if(MC_RideLog.ODO_Time > 599999)
+				MC_RideLog.ODO_Time = 0;
+			if(MC_RideLog.TRIP_Info.TripTime_MaxSpeed.TRIP_Time > 599999)
+				MC_RideLog.TRIP_Info.TripTime_MaxSpeed.TRIP_Time > 599999 = 0;
 			#endif
-			MC_RideLog.TRIP_Time++;
+			//骑行功率累计
+			MC_AvgPower.PedalPowerSum += (PedalPowerFltSum >> 10); //Wmin	
 		}
 		//存储骑行总时间
+		#if 0 //根据骑行时间自动存储
 		if(SavePeriod_Cnt >= 600)  //累计骑行600s进行存储
 		{
 		  SavePeriod_Cnt = 0;
-			SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt);			
-      SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RIDE_LOG, sizeof(MC_RideLog_Struct_t), (uint8_t*)&MC_RideLog.ODO_Km);
+			SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt);
+      SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RIDE_LOG, sizeof(MC_RideLog_Struct_t), (uint8_t*)&MC_RideLog.ODO_Km);		
 		}
+		#endif
 		
 		//平均功耗
 		MC_RunInfo.PowerPerKm = RemainDis.Power_per_km_result / 10;
 		
+		//骑行信息计算
+		do
+		{		
+			uint16_t PowerAvg;
+	    //最大车速
+			if(MC_AvgPower.SpeedMax < MC_RunInfo.BikeSpeed)
+				MC_AvgPower.SpeedMax = MC_RunInfo.BikeSpeed;
+			MC_RideInfo.SpeedMax = MC_AvgPower.SpeedMax;
+			//平均车速
+			if(MC_RideLog.TRIP_Time == 0)
+				MC_RideInfo.SpeedAvg = 0;
+			else
+				MC_RideInfo.SpeedAvg = MC_RideLog.TRIP_Km * 60 / MC_RideLog.TRIP_Time;
+			//卡路里
+			if(MC_RideLog.ODO_Time == 0)
+				PowerAvg = 0;
+			else
+				PowerAvg = MC_AvgPower.PedalPowerSum /  MC_RideLog.ODO_Time;
+			MC_RideInfo.Cal_Trip = PowerAvg * 66 * MC_RideLog.TRIP_Time / 1000; //Cal = P * 1.1 * 3.6 * t(h)
+			MC_RideInfo.Cal_Once = PowerAvg * 11 * MC_RunInfo.Ride_Time / 10000; //Cal = P * 1.1 * 3.6 * t(h)
+		}while(0);	
 	}
 }
 
@@ -308,8 +350,8 @@ void MC_DebugInfo_Update(void)
 		MC_DebugInfo.SysFSM2 = FOC_Status;                                //FOC状态
 		MC_DebugInfo.SysFSM3 = 0;
 		MC_DebugInfo.SysFSM4 = 0;
-		MC_DebugInfo.IdRef = IqFluxLessRef;                               //IdRef
-		MC_DebugInfo.IqRef = IdFluxLessRef;                               //IqRef
+		MC_DebugInfo.IdRef = IdFluxLessRef;                               //IdRef
+		MC_DebugInfo.IqRef = IqFluxLessRef;                               //IqRef
 		MC_DebugInfo.UdRef = Stat_Volt_q_d.qV_Component2;                 //UdRef
 		MC_DebugInfo.UqRef = Stat_Volt_q_d.qV_Component1;                 //UqRef
 		MC_DebugInfo.PedalTorquePer = ADC_SensorData.TorqueSensor;        //力矩AD，减去零点
@@ -647,6 +689,7 @@ void PowerOff_Process(TrueOrFalse_Flag_Struct_t ReturnEnable)
 		MC_PowerOffBkp.Run_Time = MC_RunLog1.RunTime;
 		MC_PowerOffBkp.Log_ODO_Km = MC_RunLog1.ODO_Km;
 		MC_PowerOffBkp.Log_ODO_Time = MC_RunLog1.ODO_Time;
+		MC_PowerOffBkp.PedalPoweSum = MC_AvgPower.PedalPowerSum;
 		SaveDataToEEPROM_Flash(EEPROM_FLASH_ADDR_POWEROFF_BKP, (uint8_t*)&MC_PowerOffBkp.ODO_Km, 40);//写入掉电临时保存数据，写入前该区域需擦除为0xFF才能操作成功
 		SaveDataToEEPROM_Flash(EEPROM_FLASH_ADDR_POWEROFF_BKP_FLAG, (uint8_t*)"FLAG", 4); //掉电存储的数据标志更新
 		SaveFlag = SET;
@@ -767,20 +810,25 @@ void MC_UartRxCheck_Process(void)
 }
 
 //运行总时间计算
-void MC_RunTime_Cal(uint32_t* p_Runtime)
+void MC_RunTime_Cal()
 {
   static uint32_t PeriodTimeCnt = 0;
-	static uint8_t SavePeriodCount = 0;
+	static uint32_t SavePeriodCount = 0;
 	
 	if((HAL_GetTick()- PeriodTimeCnt) >= 60000)
 	{
-	  PeriodTimeCnt = HAL_GetTick(); 
-		(*p_Runtime)++;
-		//存储运行总时间
+	  PeriodTimeCnt = HAL_GetTick();
+		MC_RunLog1.RunTime++;
 		SavePeriodCount++;
-		if(SavePeriodCount >= 10)  //自动存储周期10min
+	}
+	//自动存储历史数据
+	if(SavePeriodCount >= 10)  //自动存储周期10min
+	{
+		if(MC_CalParam.Foc_Flag == RESET)
 		{
 			SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt);
+			SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RIDE_LOG, sizeof(MC_RideLog_Struct_t), (uint8_t*)&MC_RideLog.ODO_Km);
+			SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_AVG_POWER, sizeof(MC_AvgPower_Struct_t), (uint8_t*)&MC_AvgPower.GearSt_ECO);
 			SavePeriodCount = 0;
 		}
 	}
@@ -912,7 +960,7 @@ void MC_DeviceCheck(Device_CheckInfo_Struct_t* p_Device, MC_ErrorCode_Struct_t*
 			{
 			  p_ErrorCode->ERROR_Bit.Fault_BMS_Check = 1;
 				MC_RunLog1.BMS_Check_FaultCnt++;
-				SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt);
+				RunLogSaveIndex = 1;		
 			}
 			break;
 		}
@@ -926,7 +974,7 @@ void MC_DeviceCheck(Device_CheckInfo_Struct_t* p_Device, MC_ErrorCode_Struct_t*
 			{
 			  p_ErrorCode->ERROR_Bit.Fault_PBU_Check = 1;
 				MC_RunLog1.PBU_Check_FaultCnt++;
-				SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt);
+				RunLogSaveIndex = 1;		
 			}
 			break;
 		}
@@ -940,7 +988,7 @@ void MC_DeviceCheck(Device_CheckInfo_Struct_t* p_Device, MC_ErrorCode_Struct_t*
 			{
 			  p_ErrorCode->ERROR_Bit.Fault_HMI_Check = 1;
 				MC_RunLog1.HMI_Check_FaultCnt++;
-				SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt);
+				RunLogSaveIndex = 1;		
 			}
 			break;
 		}
@@ -961,8 +1009,7 @@ void Cal_SyncClockFreq(uint16_t* Result)
 //温度历史信息处理
 void MC_TemperatureLogProcess(void)
 {
-  static uint32_t PeriodTimeCnt = 0;
-	static uint16_t SavePeriodCnt = 0;
+  static uint32_t PeriodTimeCnt = 0;	
 	static TrueOrFalse_Flag_Struct_t DataChangeFlag = FALSE;
 	
 	if(HAL_GetTick() < 10000)  //开机前10s不处理
@@ -1011,6 +1058,8 @@ void MC_TemperatureLogProcess(void)
 		}		
 		
 		//自动存储
+		#if 0
+		static uint16_t SavePeriodCnt = 0;
 		SavePeriodCnt++;
 		if((SavePeriodCnt > 12) && (DataChangeFlag == TRUE)) //1min
 		{
@@ -1018,6 +1067,7 @@ void MC_TemperatureLogProcess(void)
 			DataChangeFlag = FALSE;
 			SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt);	
 		}
+		#endif
 	}
 }
 
@@ -1082,22 +1132,40 @@ void Device_Handshake_Process(void)
 {
 	static uint32_t PeriodCnt = 0;
 	static uint8_t i = 0;
-	if((HAL_GetTick() - PeriodCnt) >= 500)
+	static uint8_t HandShakeFlag1 = 0, HandShakeFlag2 = 0;
+	
+	//开机时判断是否发送心跳
+	if(HandShakeFlag1 == 0)
+	{
+	  if(IsComOK_BMS.IsOK_Flag == TRUE)
+			HandShakeFlag1 = 1;
+	}
+	
+	if(HandShakeFlag2 == 0)
+	{
+		if(IsComOK_PBU.IsOK_Flag == TRUE)
+				HandShakeFlag2 = 1;
+	}
+	
+	//定时循环发送心跳
+	if((HAL_GetTick() - PeriodCnt) >= 1000)
 	{
  	  PeriodCnt = HAL_GetTick();
 		if(i == 0)
 		{
 		  //BMS
-		  SendData(ID_MC_TO_BMS, MODE_READ, 0x3009, (uint8_t*)"HANDSHAKE");
+			if(HandShakeFlag1 == 1)
+				SendData(ID_MC_TO_BMS, MODE_READ, 0x3009, (uint8_t*)"HANDSHAKE");
 			i = 1;
 		}
 		else if(i == 1)
 		{
 		  //OBC
-		  SendData(ID_MC_TO_PBU, MODE_READ, 0x5009, (uint8_t*)"HANDSHAKE");
+			if(HandShakeFlag2 == 1)
+				SendData(ID_MC_TO_PBU, MODE_READ, 0x5009, (uint8_t*)"HANDSHAKE");
 			i = 0;
 		}
 		
-	}			
+	}		
 }
 /**************************全局函数定义结束*****************/

User/Src/var.c

@@ -44,6 +44,7 @@ ComOK_Check_Struct_t IsComOK_HMI = {FALSE, 0};            //HMI通
 ComOK_Check_Struct_t IsComOK_BMS = {FALSE, 0};            //BMS通信状态标志
 MC_AttitudeAngle_Struct_t MC_AttitudeAngle;               //姿态传感器数值
 MC_RideLog_Struct_t MC_RideLog;                           //骑行历史
+MC_RideInfo_Struct_t MC_RideInfo;                         //骑行信息
 MC_AvgPower_Struct_t MC_AvgPower;                         //助力平均功耗
 MCU_Manufacturter_Struct_t MCUManufacturer;               //MCU生厂商
 uint16_t SpeedRatio;                                      //传动比计算结果
@@ -51,6 +52,7 @@ uint16_t HardwareVersion_AD=0;                            //硬
 TrueOrFalse_Flag_Struct_t VersionIdentifyFinishedFlag = FALSE; //硬件识别结束标识
 TrueOrFalse_Flag_Struct_t PowerDown_SaveFlag = FALSE;          //断电标识
 Bike_RatioCal_Struct_t Bike_RatioCalParam = {0,0,0,100,10,0,0};//传动比计算
+int32_t PedalPowerFltSum = 0;                             //踩踏功率
 
 //BMS默认设计信息
 const BMS_DesignInfo_Struct_t BMS_DesignInfo_Default =
@@ -311,7 +313,9 @@ const MC_AvgPower_Struct_t MC_AvgPower_Default =
 	(uint16_t)160,
 	(uint16_t)190,
 	(uint16_t)270,
-	(uint16_t)180
+	(uint16_t)180,
+	(uint16_t)0,
+	(uint32_t)0,
 };
 
 //MC骑行历史信息，占用32bytes
@@ -669,6 +673,7 @@ void Var_Init(void)
 	
 	//软件标识
 	strncpy(Firmware_Special, (char*)"TC011000-MS0000-V0r1.           ", 32);
+	
 	//编译时间
 	do
 	{

修改说明.txt

@@ -600,6 +600,17 @@ V6.2.1_20231121-3
 17、马达参数增加极对数；
 19、生产信息增加产品标识。
 
+V6.2.2_20231118-1 20240408
+1、解决低电量时SOC=0xFF的问题。
+
+V6.2.2_20231118-1 20240801
+1、增加仪表和电池的心跳包，轮流定时1s发送。
+
+V6.2.2_20231118-1 20250513
+1、更改踏频传感器型号，方向和频率由传感器输出，根据硬件版本识别踏频传感器型号，调用不同的踏频计算函数；
+2、增加平均车速、最大车速、卡路里计算，发送骑行历史时一起发送，平均功耗预留位用于存储最大车速和骑行消耗总能量；
+3、模拟I2C延时参数由50改为20，延迟一次时间由3.7us缩短为1.5us，读一次启动值时间由2.84ms缩短为1.42ms；
+4、取消骑行3km或骑行10min自动存储数据，取消温度最值更新时自动存储数据，统一用10min定时存储MC_RunLog1、MC_RideLog、MC_AvgPower。