V1.0.0 20190814

1、在MC_CanRxCheck_Process()中增加对HMI、BMS实时判断是否离线，相应的CAN解析中做标志置位处理；
2、三相电流采集中A相IO初始化修改；
3、MC_TE_SensorStatus中MCU_Voltage采用由TE发送过来的值，而不是根据主控MCU采集计算；
4、增加TIM2采集计算TE发送的1M同步信号频率，并根据TE的UART发送过来的值作比较判断；
5、修改刹车和GearSensor的检测，并增加根据GearSensor_Flag状态标志控制电机停机；
6、增加骑行总时间的统计和存储功能，变量名称为ODO_Time；
7、收到BMS运行信息时，增加对RemainDis.IsBMS_ComOK_Flag的置位，用于续航计算；
8、增加HMI和MC之间关于轮胎周长的查询和配置功能；
9、增加ECO、NORM档位变化时限流值的线性变化；
10、低力矩停机时间的计算方法优化；
11、12V电源驱动函数的优化；
12、低压和过压保护修改为根据设置马达参数中的额定电压判断；
13、开路计算SOC改为根据放电曲线中的容量值股钻；
14、车速计算方法优化，改用滑动滤波算法，并在前一个信号触发后超时开始对速度衰减；
15、版本号修改为V1.0.0_20190814

Core/Inc/can.h

@@ -126,6 +126,8 @@ extern uint8_t CAN_RxBuf_CDL[255];
 extern CAN_Buf_TypeDef CAN_RxBuf_Struct_CDL;
 
 extern ComOK_Check_Struct_t IsComOK_PBU;
+extern ComOK_Check_Struct_t IsComOK_HMI;
+extern ComOK_Check_Struct_t IsComOK_BMS;
 
 extern void CAN_SendData(uint16_t ID, uint8_t *Data, uint16_t Length);
 extern void CANFilterConfig_Scale32_IdMask_StandardIdOnly(void);

Core/Src/adc.c

@@ -292,11 +292,11 @@ void HAL_ADC_MspInit(ADC_HandleTypeDef* adcHandle)
     __HAL_RCC_ADC2_CLK_ENABLE();
   
     /**ADC2 GPIO Configuration    
-    PA0-WKUP     ------> ADC2_IN0
     PA1     ------> ADC2_IN1
     PA2     ------> ADC2_IN2 
+		PA3     ------> ADC2_IN3
     */
-    GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2;
+    GPIO_InitStruct.Pin = GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3;
     GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 		
@@ -349,11 +349,11 @@ void HAL_ADC_MspDeInit(ADC_HandleTypeDef* adcHandle)
     __HAL_RCC_ADC2_CLK_DISABLE();
   
     /**ADC2 GPIO Configuration    
-    PA0-WKUP     ------> ADC2_IN0
     PA1     ------> ADC2_IN1
     PA2     ------> ADC2_IN2 
+		PA3     ------> ADC2_IN3
     */
-    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2);
+    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);
 
   /* USER CODE BEGIN ADC2_MspDeInit 1 */
 
@@ -463,10 +463,7 @@ void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
 	TorqueFltSum += ((Temp_32 << 10) - TorqueFltSum) >> 8;
 	ADC_SensorData.TorqueSensor = TorqueFltSum >> 10;
 	#endif
-		
-	//更新TE工作电压
-	MC_TE_SensorStatus.MCU_Voltage = (uint32_t)ADC1_Result[ADC1_RANK_3V3_TE] * 2 * 3300 >> 12;//3300 * 2 / 4095
-	
+			
 	//更新指拨
 	Temp_32 = ADC1_Result[ADC1_RANK_GAS] - GasSensor_OffSet;
 	ADC_SensorData.GasSensor = (Temp_32 <= 0) ? 0 : Temp_32;
@@ -476,8 +473,6 @@ void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
 	Temp_32 = (int32_t)1430 - Temp_32;
 	MC_RunInfo.T_MCU = (uint8_t)((Temp_32 * 238 >> 10) + 25 + 40);
 	
-	//更新Vref
-	
 }
 
 //ADC1和ADC2数据滑动滤波

Core/Src/can.c

@@ -56,6 +56,8 @@ uint8_t CAN_RxBuf_CDL[255];
 CAN_Buf_TypeDef CAN_RxBuf_Struct_CDL = {0,255,0,0,0,0,CAN_RxBuf_CDL,0,FALSE};
 
 ComOK_Check_Struct_t IsComOK_PBU = {TRUE, 0};
+ComOK_Check_Struct_t IsComOK_HMI = {TRUE, 0};
+ComOK_Check_Struct_t IsComOK_BMS = {TRUE, 0};
 /* USER CODE END 0 */
 
 CAN_HandleTypeDef hcan;

Core/Src/main.c

@@ -120,6 +120,7 @@ int main(void)
   /* Initialize all configured peripherals */
   MX_GPIO_Init();
 	MX_TIM1_Init();
+  MX_TIM2_Init();
 	MX_TIM3_Init();
   MX_DMA_Init();
 	#if DEBUG
@@ -134,6 +135,8 @@ int main(void)
 	ADC_Start();
 	HAL_Delay(20);
 	
+	HAL_TIM_Base_Start(&htim2);
+	
 	//变量初始化
 	Var_Init();
 	
@@ -204,8 +207,8 @@ int main(void)
 			//UART数据解析及处理
 			UartRx_Process();
 			
-			//PBU通信状态检测
-	    MC_CanRxCheck_Process(MC_WorkMode, &MC_ControlCode.GearSt);
+			//通信状态检测
+	    MC_CanRxCheck_Process(MC_ConfigParam.NoPBU_Flag, PBU_ConfigParam.NoHMI_Flag, MC_WorkMode, &MC_ControlCode.GearSt);
 			
 			//速度传感器采集及计算
 			SpeedSensor_Process(&MC_SpeedSensorData, &MC_RunInfo.BikeSpeed, MC_ConfigParam.WheelSize);

User/Inc/motor_control.h

@@ -94,6 +94,7 @@ extern void MC_CalParam_Cal(MC_WorkMode_Struct_t p_MC_WorkMode,\
                             ADC_SensorData_Struct_t p_ADC_SensorData,\
 										        MC_GearSt_Struct_t GearSt, \
                             TrueOrFalse_Flag_Struct_t Break_Flag, \
+                            TrueOrFalse_Flag_Struct_t GearSensor_Flag, \
                             MC_CalParam_Struct_t* p_MC_CalParam);
 extern void MC_MotorStar(FlagStatus* StarFlag);
 extern void MC_MotorStop(FlagStatus* StarFlag);

User/Inc/tasks.h

@@ -16,8 +16,9 @@ extern void MC_SendRunInfo_Process(MC_WorkMode_Struct_t WorkMode);
 extern void MC_TE_SensorData_Process(uint16_t Speed, MC_TE_SensorData_Struct_t* p_MC_TE_SensorData);
 extern uint8_t MC_CadenceLimit_Cal(uint8_t Cadence, uint16_t Current, uint8_t T_Roil);
 extern void PowerOff_Process(void);
-extern void MC_CanRxCheck_Process(MC_WorkMode_Struct_t WorkMode, MC_GearSt_Struct_t* GearSt);
+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_RunTime_Cal(uint32_t* p_Runtime);
 extern void MC_OnLineCheck(OnLine_Status_Struct_t* p_OnLineStatus, MC_ErrorCode_Struct_t* p_ErrorCode);
 extern void MC_DeviceCheck(MC_ErrorCode_Struct_t* p_ErrorCode);
+extern void Cal_SyncClockFreq(uint16_t* Result);
 #endif

User/Inc/tim.h

@@ -47,6 +47,8 @@
 /* USER CODE END Includes */
 
 extern TIM_HandleTypeDef htim1;
+extern TIM_HandleTypeDef htim2;
+extern TIM_HandleTypeDef htim3; 
 /* USER CODE BEGIN Private defines */
 #define PWM_TIMER				htim1
 #define PWM_FREQ        ((uint16_t)15000)
@@ -59,6 +61,7 @@ extern TIM_HandleTypeDef htim1;
 /* USER CODE END Private defines */
 
 void MX_TIM1_Init(void);
+void MX_TIM2_Init(void);
 void MX_TIM3_Init(void);
 void HAL_TIM_MspPostInit(TIM_HandleTypeDef *htim);
 /* USER CODE BEGIN Prototypes */

User/Inc/var.h

@@ -33,7 +33,8 @@ typedef struct
 	uint8_t T_PCB;                               //PCB温度 +40℃，地址偏移21
 	uint8_t T_Roil;                              //绕组温度 +40℃，地址偏移22
 	uint8_t T_MCU;                               //MCU温度 +40℃，地址偏移23
-	uint8_t RS[8];                               //预留 8bytes
+	uint32_t ODO_Time;                           //骑行总时间 1s，地址偏移24
+	uint8_t RS[4];                               //预留 4bytes
 }MC_RunInfo_Struct_t;
 
 //电机故障码，占用空间4bytes
@@ -126,8 +127,8 @@ typedef struct
 
 typedef enum MC_SUPPORTFLAG
 {
-  MC_SUPPORT_ENABLE = (uint8_t)0xAA,  //不支持
-	MC_SUPPORT_DISABLE = (uint8_t)0x55  //支持
+  MC_SUPPORT_ENABLE = (uint8_t)0xAA,  //支持
+	MC_SUPPORT_DISABLE = (uint8_t)0x55  //不支持
 }MC_SupportFlag_Struct_t;
 
 //用户配置参数，占用空间32bytes
@@ -200,7 +201,7 @@ typedef struct
 	uint8_t T_Coil_Min;	             //绕组历史最低温，地址偏移41
 	uint8_t T_MCU_Max;               //MCU历史最高温，地址偏移42
 	uint8_t T_MCU_Min;               //MCU历史最低温，地址偏移43
-	uint8_t RS[4];
+	uint8_t ODO_Time;                //骑行总时间，地址偏移44
 }MC_RunLog_Struct_t;
 
 //MC版本信息，占用空间64bytes
@@ -288,6 +289,8 @@ typedef struct
 {
 	TE_ErrorCode_Struct_t TE_ErrorCode;
 	uint16_t MCU_Voltage;
+	uint16_t SyncClockFreq;
+	uint16_t RS;
 }MC_TE_SensorStatus_Struct_t;
 
 //发给TE传感器结果
@@ -352,6 +355,7 @@ extern uint8_t UserString3[16];
 extern Device_CheckInfo_Struct_t MC_CheckInfo;
 extern MC_TE_SensorStatus_Struct_t MC_TE_SensorStatus;
 extern MC_TE_SensorData_Struct_t MC_TE_SensorData;
+extern uint16_t MC_TE_SyncClockFreqScan;
 extern MC_AssistParam_Struct_t MC_AssisParam;
 extern uint8_t MC_WalkMode_Persent;
 

User/Src/can_process.c

@@ -70,14 +70,21 @@ void DataProcess(uint16_t ID, uint8_t Mode, uint16_t Cmd, uint8_t* Data)
 	switch(ID)
 	{		
 		//处理BMS发送的指令
-		case ID_BMS_BC: case ID_BMS_TO_PBU:
+		case ID_BMS_BC: case ID_BMS_TO_MC:
 		{
 			switch(Cmd)			
 			{
 		  	//BMS广播的指令
 				case 0x1010://BMS运行信息
 				{
-				  memcpy(&BMS_RunInfo.Voltage, Data, DataLength);
+					//更新电池运行信息
+					memcpy(&BMS_RunInfo.Voltage, Data, DataLength); 
+					//电池通信正常标志置位，用于续航计算
+					RemainDis.IsBMS_ComOK_Flag = TRUE;              
+					RemainDis.BMS_Com_DelayTimeCnt = HAL_GetTick();
+					//BMS通信正常标志置位
+			    IsComOK_BMS.IsOK_Flag = TRUE;
+			    IsComOK_BMS.OK_TrigTime = HAL_GetTick();
 					break;
 				}
 				case 0x1308://关机指令
@@ -116,11 +123,7 @@ void DataProcess(uint16_t ID, uint8_t Mode, uint16_t Cmd, uint8_t* Data)
 		}
 		//处理PBU发送的指令
 		case ID_PBU_BC: case ID_PBU_TO_MC:
-		{
-		  //PBU通信正常标志置位
-			IsComOK_PBU.IsOK_Flag = TRUE;
-			IsComOK_PBU.OK_TrigTime = HAL_GetTick();
-			
+		{	  		
 			switch(Cmd)
 			{
 				//PBU广播的指令
@@ -146,6 +149,9 @@ void DataProcess(uint16_t ID, uint8_t Mode, uint16_t Cmd, uint8_t* Data)
 					Update_MC_ControlCode_Back();
 		      MC_RunInfo.GearSt = MC_ControlCode.GearSt;//当前助力档位更新
 					SendData(ID_MC_BC, MODE_REPORT, 0x1020, (uint8_t*)&MC_RunInfo.BikeSpeed);
+					//PBU通信正常标志置位
+			    IsComOK_PBU.IsOK_Flag = TRUE;
+			    IsComOK_PBU.OK_TrigTime = HAL_GetTick();
 					break;
 				}
 				case 0x3105://PBU在线检测反馈
@@ -167,7 +173,7 @@ void DataProcess(uint16_t ID, uint8_t Mode, uint16_t Cmd, uint8_t* Data)
 			break;
 		}
 		//处理HMI发送的指令
-		case ID_HMI_BC: case ID_HMI_TO_PBU:
+		case ID_HMI_BC: case ID_HMI_TO_MC:
 		{
 		  switch(Cmd)
 			{
@@ -182,6 +188,13 @@ void DataProcess(uint16_t ID, uint8_t Mode, uint16_t Cmd, uint8_t* Data)
 				  memcpy(HMI_CheckInfo.CheckCode, Data, DataLength);
 					break;
 				}
+				case 0x1508://HMI运行信息
+				{
+				  //HMI通信正常标志置位
+			    IsComOK_HMI.IsOK_Flag = TRUE;
+			    IsComOK_HMI.OK_TrigTime = HAL_GetTick();
+					break;
+				}
 				//HMI发送MC的指令
 				case 0x3000://查询电机版本信息
 				{
@@ -193,12 +206,14 @@ void DataProcess(uint16_t ID, uint8_t Mode, uint16_t Cmd, uint8_t* Data)
 				case 0x3100://查询电机配置参数
 				{
 				  GetParamFromEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_CONFIG_PARAM, sizeof(MC_ConfigParam), &MC_ConfigParam.RS1);
+					Data[0] = MC_ConfigParam.WheelSize;
 					Data[1] = MC_ConfigParam.StarModel;
 					SendData(ID_MC_TO_HMI, MODE_REPORT, 0x7308, Data);
 					break;
 				}
 				case 0x3208://设置电机配置参数
 				{
+					MC_ConfigParam.WheelSize = Data[0];
 					MC_ConfigParam.StarModel = (MC_StarMode_Struct_t)Data[1];
 					SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_CONFIG_PARAM, sizeof(MC_ConfigParam), &MC_ConfigParam.RS1);
 					SendData(ID_MC_TO_HMI, MODE_REPORT, 0x7403, (uint8_t*)"ACK");

User/Src/eeprom_24c02.c

@@ -308,6 +308,7 @@ int8_t CopyDataFromEEpprom_24C02(I2C_Handle_Struct_t* I2C_Handle)
 	  return ACK_FAIL;
 	}
 	MC_RunInfo.ODO_Km = (uint16_t)MC_RunLog.ODO_Km / 10;
+	MC_RunInfo.ODO_Time = MC_RunLog.ODO_Time;
 	//读出力矩传感器零点偏移值
 	if(GetParamFromEEprom_24C02(I2C_Handle, EEPROM_24C02_ADDR_TORQUE_OFFSET, sizeof(TorqueOffSetData_Struct_t), (uint8_t*)&TorqueOffSetData.Data[0]))
 	{

User/Src/fault_check.c

@@ -430,6 +430,7 @@ void MC_Fault_TE_Process(MC_TE_SensorStatus_Struct_t* p_MC_TE_SensorStatus, True
 	static uint32_t DelayTimeCnt_Sensor = 0;
 	static FlagStatus SensorCheckFault_Falg = RESET;
 	static FlagStatus TE_ComFault_Flag = RESET;
+	static FlagStatus TE_SyncClockFault_Flag = RESET;
 	
 	//传感器检测异常判断
 	if(SensorCheckFault_Falg == RESET)
@@ -486,8 +487,19 @@ void MC_Fault_TE_Process(MC_TE_SensorStatus_Struct_t* p_MC_TE_SensorStatus, True
 		}
 	}
 	
+	//TE时钟判断
+	if(  (MC_TE_SyncClockFreqScan < (p_MC_TE_SensorStatus->SyncClockFreq - 200))
+		 ||(MC_TE_SyncClockFreqScan > (p_MC_TE_SensorStatus->SyncClockFreq + 200)))
+	{
+	  TE_SyncClockFault_Flag = SET;
+	}
+	else
+	{
+	  TE_SyncClockFault_Flag = RESET;
+	}
+	
 	//故障码输出
-	if((SensorCheckFault_Falg == RESET) && (TE_ComFault_Flag == RESET))
+	if((SensorCheckFault_Falg == RESET) && (TE_ComFault_Flag == RESET) && (TE_SyncClockFault_Flag == RESET))
 	{
 	  p_MC_ErrorCode->ERROR_Bit.Fault_MCU = 0;
 	}
@@ -497,7 +509,7 @@ void MC_Fault_TE_Process(MC_TE_SensorStatus_Struct_t* p_MC_TE_SensorStatus, True
 		{
       p_MC_ErrorCode->ERROR_Bit.Fault_Circuit = 1;  //认为电路故障
 		}
-		if(TE_ComFault_Flag == SET)                     //认为MCU故障
+		if((TE_ComFault_Flag == SET) || (TE_SyncClockFault_Flag == SET))   //认为MCU故障
 		{
 	  	p_MC_ErrorCode->ERROR_Bit.Fault_MCU = 1;
 		}
@@ -724,23 +736,23 @@ void MC_Fault_Check_Process(void)
 	MC_Fault_TorqueSensor_Process(ADC1_Result[ADC1_RANK_TORQUE_SENSOR], MC_ControlCode.GearSt, MC_CadenceResult, &MC_ErrorCode);
 	
 	//相线故障检测
-//	MC_Fault_PhaseLine_Process(MC_CalParam.Foc_Flag, MC_RunInfo.BusCurrent, MC_RunInfo.MotorSpeed, ADC_3ShuntCurrent_RMSValue, &MC_ErrorCode);
+	MC_Fault_PhaseLine_Process(MC_CalParam.Foc_Flag, MC_RunInfo.BusCurrent, MC_RunInfo.MotorSpeed, ADC_3ShuntCurrent_RMSValue, &MC_ErrorCode);
 
 	//温度传感器故障检测
-//	MC_Fault_NTCSensor_Process(MC_RunInfo.T_PCB, MC_RunInfo.T_Roil, &MC_ErrorCode);
+	MC_Fault_NTCSensor_Process(MC_RunInfo.T_PCB, MC_RunInfo.T_Roil, &MC_ErrorCode);
 
 	//踏频传感器故障检测
-//	MC_Fault_CadenceSensor_Process(ADC_SensorData.TorqueSensor, MC_RunInfo.BikeSpeed, &MC_ErrorCode);
+	MC_Fault_CadenceSensor_Process(ADC_SensorData.TorqueSensor, MC_RunInfo.BikeSpeed, &MC_ErrorCode);
 
 	//指拨故障检测
-//	MC_Fault_GasSensor_Process(ADC1_Result[ADC1_RANK_GAS], &MC_ErrorCode);
+	MC_Fault_GasSensor_Process(ADC1_Result[ADC1_RANK_GAS], &MC_ErrorCode);
 
 	//MOS故障检测
-//	MC_Fault_MOS_Process(ADC_3ShuntCurrent_RMSValue, &MC_ErrorCode);
+	MC_Fault_MOS_Process(ADC_3ShuntCurrent_RMSValue, &MC_ErrorCode);
 
   //TE故障检测
-//	MC_Fault_TE_Process(&MC_TE_SensorStatus, IsComOK_TE, &MC_ErrorCode);
+	MC_Fault_TE_Process(&MC_TE_SensorStatus, IsComOK_TE, &MC_ErrorCode);
 	
 	//电路故障检测
-//	MC_Fault_Circuit_Process(&MC_ErrorCode);
+	MC_Fault_Circuit_Process(&MC_ErrorCode);
 }

User/Src/key_driver.c

@@ -27,32 +27,37 @@ void _GPIO_Read(Key_TypeDef* Key)
 
 void Key_Check(Key_TypeDef* Key, uint32_t DelayTime, TrueOrFalse_Flag_Struct_t* Flag)
 {
-	
 	_GPIO_Read(Key);
-	if(Key->Trg & 0x01)//表示按键有触发(下降沿)
+	if(Key->Trg & 0x01)//表示有触发(下降沿)
 	{
 	  Key->PressFlasg  = 1;
-		Key->TimeCnt = HAL_GetTick();//按键按下时刻，计时赋初值
+		*Flag = TRUE;//有效信号
+		Key->TimeCnt = HAL_GetTick();//计时赋初值
 	}
-	if(Key->PressFlasg == 1)//按键被触发一次
+	if(Key->PressFlasg == 1)//被触发一次
 	{
-	  if(Key->Cont & 0x01)//表示按键未放开
+	  if(Key->Cont == 0x00)//表示松开
 	  {
-			if((HAL_GetTick() - Key->TimeCnt) > DelayTime)
+			Key->TimeCnt = HAL_GetTick();
+		  Key->PressFlasg = 0;
+			*Flag = FALSE;//松开释放信号
+	  }
+	}
+	if(*Flag == 1)//超时自动释放信号
+	{
+    if(DelayTime != 0) //超时设置值为0时不自动释放信号
+		{
+			if((HAL_GetTick() - Key->TimeCnt) > DelayTime)	 
 			{
-			  Key->TimeCnt = HAL_GetTick();
+				Key->TimeCnt = HAL_GetTick();
 				Key->PressFlasg = 0;
-				*Flag = TRUE;//检测到刹车信号
-	      return;
-			}
-	  }
+				*Flag = FALSE;//超时自动释放信号
+			}	
+		}	
 	}
-	if(Key->Cont == 0x00)//按键弹起
+	else
 	{
 	  Key->TimeCnt = HAL_GetTick();
-	  Key->PressFlasg = 0;
-		*Flag = FALSE;//释放刹车信号
-	  return;
 	}
 	return;
 }
@@ -116,8 +121,8 @@ void Break_Check(TrueOrFalse_Flag_Struct_t* BreakFlag)
   static TrueOrFalse_Flag_Struct_t IsBreakTrig_Left_Flag = FALSE;//刹车标志
   static TrueOrFalse_Flag_Struct_t IsBreakTrig_Right_Flag = FALSE;//刹车标志
 	
-	Key_Check(&Key_Break_Left, 100, &IsBreakTrig_Left_Flag);
-	Key_Check(&Key_Break_Right, 100, &IsBreakTrig_Right_Flag);
+	Key_Check(&Key_Break_Left, 0, &IsBreakTrig_Left_Flag);   //被触发时认为有效信号，松开时释放
+	Key_Check(&Key_Break_Right, 0, &IsBreakTrig_Right_Flag); //被触发时认为有效信号，松开时释放
 	
 	*BreakFlag = (TrueOrFalse_Flag_Struct_t)((uint8_t)IsBreakTrig_Left_Flag & (uint8_t)IsBreakTrig_Right_Flag);
 }
@@ -125,6 +130,6 @@ void Break_Check(TrueOrFalse_Flag_Struct_t* BreakFlag)
 //GearSensor检测函数
 void GearSensor_Check(TrueOrFalse_Flag_Struct_t *Flag)
 {
-  Key_Check(&Key_GearSensor, 100, Flag);
+  Key_Check(&Key_GearSensor, 1000, Flag);//被触发时认为有效信号，松开时释放或超时1000ms释放
 }
 

User/Src/motor_control.c

@@ -34,7 +34,7 @@ FlagStatus MC_StarFlag = RESET;
 
 /*************************局部函数定义***********************/
 //限流值线性变化处理
-uint16_t MC_CurrentLimit_Linear_Process(uint16_t SetData, uint16_t PresentData)
+uint16_t MC_CurrentLimit_Linear_Process(uint16_t SetData, uint16_t PresentData, uint16_t AddCnt, uint16_t DecCnt)
 {
   int16_t ErrorData;
 	uint16_t Result;
@@ -42,11 +42,25 @@ uint16_t MC_CurrentLimit_Linear_Process(uint16_t SetData, uint16_t PresentData)
 	ErrorData = SetData - PresentData;
 	if(ErrorData > 0)  //升速
 	{
-	  Result = PresentData + 5;
+	  if(ErrorData >= AddCnt)
+		{
+		  Result = PresentData + AddCnt;
+		}
+		else
+		{
+		  Result = SetData;
+		}
 	}
 	else if(ErrorData < 0)  //降速
 	{
-	  Result = PresentData - 1;
+	  if((-ErrorData) >= DecCnt)
+		{
+		  Result = PresentData - DecCnt;
+		}
+		else
+		{
+		  Result = SetData;
+		}
 	}
 	else
 	{
@@ -57,13 +71,13 @@ uint16_t MC_CurrentLimit_Linear_Process(uint16_t SetData, uint16_t PresentData)
 }
 
 //助力模式判断处理
-MC_AssistRunMode_Struct_t MC_JudgeAsistRunMode_Process(uint16_t GasSensorData, MC_GearSt_Struct_t GearSt, TrueOrFalse_Flag_Struct_t Break_Flag)
+MC_AssistRunMode_Struct_t MC_JudgeAsistRunMode_Process(uint16_t GasSensorData, MC_GearSt_Struct_t GearSt, TrueOrFalse_Flag_Struct_t Break_Flag, TrueOrFalse_Flag_Struct_t GearSensor_Flag)
 {
   MC_AssistRunMode_Struct_t MC_AssistRunMode_Result;
 	
 	if(MC_ErrorCode.Code == 0)  // 无故障
 	{
-	  if((GearSt != MC_GearSt_OFF) && (Break_Flag == FALSE))
+	  if((GearSt != MC_GearSt_OFF) && (Break_Flag == FALSE) && (GearSensor_Flag == FALSE))
 		{
 		  //进入指拨模式
 			if(GasSensorData > 100)  
@@ -97,12 +111,16 @@ MC_AssistRunMode_Struct_t MC_JudgeAsistRunMode_Process(uint16_t GasSensorData, M
 		{
 	  	MC_AssistRunMode_Result = MC_AssistRunMode_INVALID;
 		}
+		Power12V_Driver_Process(SET);
 	}
 	else  //存在故障
 	{
 	  MC_AssistRunMode_Result = MC_AssistRunMode_INVALID;
 		MC_ControlCode.GearSt = MC_GearSt_OFF;
 		MC_ControlCode_Back.GearSt = (MC_GearSt_Struct_t)~MC_ControlCode.GearSt;
+		#if 0
+		Power12V_Driver_Process(RESET);
+		#endif
 	}
 	
 	return MC_AssistRunMode_Result;
@@ -339,16 +357,14 @@ MC_CalParam_Struct_t MC_AssistRunMode_Torque_Process(uint16_t SenorData, MC_Gear
 	}
 	else
 	{
-		if(MC_RunInfo.MotorSpeed > 300)
+		if(MC_RunInfo.MotorSpeed > 200)
 		{
-		  TorqueStopDelayTime = 327600 / MC_RunInfo.MotorSpeed + 200;
+		  TorqueStopDelayTime = 163800 / MC_RunInfo.MotorSpeed;
 		}
 		else
 		{
 		  TorqueStopDelayTime = 1200;
 		}
-		TorqueStopDelayTime = (TorqueStopDelayTime > 1200) ? 1200 : TorqueStopDelayTime;
-		TorqueStopDelayTime = (TorqueStopDelayTime < 300) ? 300 : TorqueStopDelayTime;
 		
 		if((HAL_GetTick() - TorqueStopDelayTimeCnt) > TorqueStopDelayTime)//超时1200ms
 		{
@@ -357,7 +373,7 @@ MC_CalParam_Struct_t MC_AssistRunMode_Torque_Process(uint16_t SenorData, MC_Gear
 	}
 	
 	//启动值判断
-	if(MC_RunInfo.BikeSpeed > 60)
+	if(MC_RunInfo.BikeSpeed > 60) 
 	{
 		TorqueStartData =  (MC_TorqueCorrectParam.StarData < 200 ? 150 \
 																														 : (MC_TorqueCorrectParam.StarData > 700 ? 525 \
@@ -426,8 +442,8 @@ MC_CalParam_Struct_t MC_AssistRunMode_Torque_Process(uint16_t SenorData, MC_Gear
 				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_ConfigParam.CurrentLimit * 1000 >> 17);
-				CurrentLimitPresent = CurrentLimitSet * 100;
+				CurrentLimitSet = (uint32_t)(MC_AssisParam.Gear_ECO.CurrentMax_K * MC_ConfigParam.CurrentLimit * 1000 >> 17) * 100;
+				CurrentLimitPresent = MC_CurrentLimit_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
@@ -457,8 +473,8 @@ MC_CalParam_Struct_t MC_AssistRunMode_Torque_Process(uint16_t SenorData, MC_Gear
 				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_ConfigParam.CurrentLimit * 1000 >> 17);
-				CurrentLimitPresent = CurrentLimitSet * 100;
+				CurrentLimitSet = (uint32_t)(MC_AssisParam.Gear_NORM.CurrentMax_K * MC_ConfigParam.CurrentLimit * 1000 >> 17) * 100;
+				CurrentLimitPresent = MC_CurrentLimit_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
@@ -489,7 +505,7 @@ MC_CalParam_Struct_t MC_AssistRunMode_Torque_Process(uint16_t SenorData, MC_Gear
 				
 				//限流参数设置
 				CurrentLimitSet = (uint32_t)(MC_AssisParam.Gear_SPORT.CurrentMax_K * MC_ConfigParam.CurrentLimit * 1000 >> 17) * MC_CadenceLimit_K;
-				CurrentLimitPresent = MC_CurrentLimit_Linear_Process(CurrentLimitSet, CurrentLimitPresent);
+				CurrentLimitPresent = MC_CurrentLimit_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
@@ -520,7 +536,7 @@ MC_CalParam_Struct_t MC_AssistRunMode_Torque_Process(uint16_t SenorData, MC_Gear
 				
 				//限流参数设置
 				CurrentLimitSet = (uint32_t)(MC_AssisParam.Gear_TURBO.CurrentMax_K * MC_ConfigParam.CurrentLimit * 1000 >> 17) * MC_CadenceLimit_K;
-				CurrentLimitPresent = MC_CurrentLimit_Linear_Process(CurrentLimitSet, CurrentLimitPresent);
+				CurrentLimitPresent = MC_CurrentLimit_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
@@ -548,7 +564,7 @@ MC_CalParam_Struct_t MC_AssistRunMode_Torque_Process(uint16_t SenorData, MC_Gear
 				
 				//限流参数设置
 				CurrentLimitSet = (uint32_t)(MC_AssisParam.Gear_SMART.CurrentMax_K * MC_ConfigParam.CurrentLimit * 1000 >> 17) * MC_CadenceLimit_K;
-				CurrentLimitPresent = MC_CurrentLimit_Linear_Process(CurrentLimitSet, CurrentLimitPresent);
+				CurrentLimitPresent = MC_CurrentLimit_Linear_Process(CurrentLimitSet, CurrentLimitPresent, 5 ,1);
 				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
@@ -736,13 +752,18 @@ void MC_ControlParam_Init(void)
 }
 
 //控制参数输入值计算
-void MC_CalParam_Cal(MC_WorkMode_Struct_t p_MC_WorkMode, ADC_SensorData_Struct_t p_ADC_SensorData, MC_GearSt_Struct_t GearSt, TrueOrFalse_Flag_Struct_t Break_Flag, MC_CalParam_Struct_t* p_MC_CalParam)
+void MC_CalParam_Cal(MC_WorkMode_Struct_t p_MC_WorkMode, \
+	                   ADC_SensorData_Struct_t p_ADC_SensorData, \
+                     MC_GearSt_Struct_t GearSt, \
+                     TrueOrFalse_Flag_Struct_t Break_Flag, \
+                     TrueOrFalse_Flag_Struct_t GearSensor_Flag, \
+                     MC_CalParam_Struct_t* p_MC_CalParam)
 {
 	MC_AssistRunMode_Struct_t MC_AssistRunMode_Temp;
 	static FlagStatus MC_AssistRunMode_ShiftFlag = RESET;  //电机助力模式切换标志
 	
 	//根据指拨信号、助力档位指令、刹车信号判断助力模式
-	MC_AssistRunMode_Temp = MC_JudgeAsistRunMode_Process(p_ADC_SensorData.GasSensor, GearSt, Break_Flag);
+	MC_AssistRunMode_Temp = MC_JudgeAsistRunMode_Process(p_ADC_SensorData.GasSensor, GearSt, Break_Flag, GearSensor_Flag);
 	
 	//发生助力模式切换时，清空变量
 	if(MC_AssistRunMode_Temp != p_MC_CalParam->AssistRunMode)

User/Src/power12V_driver.c

@@ -1,5 +1,7 @@
 #include "power12V_driver.h"
 
+FlagStatus SwitchOnFlag; //开关打开标志，初始化为关闭标志
+
 //12V驱动IO初始化
 void Power12V_Driver_Init(void)	
 {
@@ -15,19 +17,29 @@ void Power12V_Driver_Init(void)
   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
   HAL_GPIO_Init(POWER12V_EN_GPIO_Port, &GPIO_InitStruct);
+	
+	SwitchOnFlag = RESET;  //初始化为关闭标志
 }
 
 //12V驱动IO设置处理
 void Power12V_Driver_Process(FlagStatus SwitchStatus)
 {
-  if(SwitchStatus == SET)
+	if(SwitchStatus == SET)
 	{
-	  //打开12V驱动电源
-	  HAL_GPIO_WritePin(POWER12V_EN_GPIO_Port, POWER12V_EN_Pin, GPIO_PIN_SET);
+	  if(SwitchOnFlag == RESET)
+		{
+		  //打开12V驱动电源
+	    HAL_GPIO_WritePin(POWER12V_EN_GPIO_Port, POWER12V_EN_Pin, GPIO_PIN_SET);
+			SwitchOnFlag = SET;
+		}
 	}
-	else
+	else if(SwitchStatus == RESET)
 	{
-	  //关闭12V驱动电源
-    HAL_GPIO_WritePin(POWER12V_EN_GPIO_Port, POWER12V_EN_Pin, GPIO_PIN_RESET);
+	  if(SwitchOnFlag == SET)
+		{
+	  	//关闭12V驱动电源
+      HAL_GPIO_WritePin(POWER12V_EN_GPIO_Port, POWER12V_EN_Pin, GPIO_PIN_RESET);
+	  	SwitchOnFlag = RESET;
+		}
 	}
 }

User/Src/protect_check.c

@@ -10,7 +10,7 @@ FlagStatus MC_Protect_OverCurrentTrig_Flag = RESET;
 
 /******************************局部函数定义******************************/
 //低压保护检测
-void MC_Protect_UnderVoltage_Process(uint16_t BusVoltage, uint16_t DesignVoltage, MC_ErrorCode_Struct_t* p_MC_ErrorCode)
+void MC_Protect_UnderVoltage_Process(uint16_t BusVoltage, uint8_t DesignVoltage, MC_ErrorCode_Struct_t* p_MC_ErrorCode)
 {
   static uint32_t uvTimeCnt = 0;
 	static uint32_t uvFaultTimeCnt = 0;
@@ -287,10 +287,10 @@ void MC_Protect_OverCurrent_Process(FlagStatus* OverCurrentTrigFlag, MC_ErrorCod
 void MC_Protect_Check_Process(void)
 {
 	//低压保护检测
-	MC_Protect_UnderVoltage_Process(MC_RunInfo.BusVoltage, BMS_DesignInfo.Voltage, &MC_ErrorCode);
+	MC_Protect_UnderVoltage_Process(MC_RunInfo.BusVoltage, MC_MotorParam.Rate_Voltage, &MC_ErrorCode);
 
 	//过压保护检测
-	MC_Protect_OverVoltage_Process(MC_RunInfo.BusVoltage, BMS_DesignInfo.Voltage, &MC_ErrorCode);
+	MC_Protect_OverVoltage_Process(MC_RunInfo.BusVoltage, MC_MotorParam.Rate_Voltage, &MC_ErrorCode);
 
 	//堵转保护检测
 	MC_Protect_RotorLock_Process(MC_RunInfo.BusCurrent, MC_HallSensorData.IsStopFlag, &MC_ErrorCode);
@@ -299,6 +299,6 @@ void MC_Protect_Check_Process(void)
 	MC_Protect_OverHeat_Process(MC_RunInfo.T_MCU, MC_RunInfo.T_PCB, MC_RunInfo.T_Roil, MC_ConfigParam.TempTH_Protect, &MC_ErrorCode);
 
 	//电压波动异常保护检测
-//	MC_Protect_VoltageChange_Process(MC_RunInfo.BusVoltage, MC_RunInfo.BusCurrent, &MC_ErrorCode);
+	MC_Protect_VoltageChange_Process(MC_RunInfo.BusVoltage, MC_RunInfo.BusCurrent, &MC_ErrorCode);
 	
 }

User/Src/remain_distance.c

@@ -479,10 +479,14 @@ uint8_t Battery_SocCal(uint16_t Voltage, uint16_t Current)
 			{
 				if((Voltage / 10) > battery_VoltageQuantity[i][0])
 				{
-					Temp = i * 100 / (sizeof(battery_VoltageQuantity) / 4);
+					Temp = battery_VoltageQuantity[i][1]  * 100 / battery_VoltageQuantity[sizeof(battery_VoltageQuantity) / 4 - 1][1];					
 					Result = 100 - Temp;
 					break;
 				}
+				else
+				{
+				  Result = 0;
+				}
 		  }
 	  }
 		PeriodTimeCnt = HAL_GetTick();

User/Src/speed_sensor.c

@@ -1,4 +1,5 @@
 #include "speed_sensor.h"
+#include "math_tools.h"
 
 
 //局部变量定义
@@ -33,8 +34,7 @@ void SpeedSensor_Process(MC_SpeedSensorData_Struct_t* p_MC_SpeedSensorData, uint
 {
 	//车速计算
 	static uint32_t PeriodTimeCnt = 0;
-	static uint32_t SpeedFltSum = 0;
-	static uint8_t Count = 0;
+	static uint16_t FiltTemp[10];
 	
 	if((HAL_GetTick() - PeriodTimeCnt) >= 50)
 	{
@@ -60,29 +60,23 @@ void SpeedSensor_Process(MC_SpeedSensorData_Struct_t* p_MC_SpeedSensorData, uint
 			}
 			p_MC_SpeedSensorData->Speed_Data = (uint32_t)WheelSize * 360 / p_MC_SpeedSensorData->DiffTime_ms;//单位0.1km/h
 			
+			//滑动均值滤波
+			*AvgResult = MovingAverageFilter(p_MC_SpeedSensorData->Speed_Data, FiltTemp, sizeof(FiltTemp) >> 1);
+			
 			//在确定停止前进行衰减
-			p_MC_SpeedSensorData->DiffTime_ms = p_MC_SpeedSensorData->DiffTime_ms * 1030 >> 10;
+			if((HAL_GetTick() - p_MC_SpeedSensorData->TrigSysTime) > (p_MC_SpeedSensorData->DiffTime_ms * 2))
+			{
+		  	p_MC_SpeedSensorData->DiffTime_ms = (p_MC_SpeedSensorData->DiffTime_ms * 1038) >> 10;
+			}
+			
 		}
 		else
 		{
 			p_MC_SpeedSensorData->Speed_Data = 0;
 			*AvgResult = 0;
-			SpeedFltSum = 0;
-			Count = 0;
 			p_MC_SpeedSensorData->DiffTime_ms = 0xFFFFFFFF;
 			return;
 		}
-		//计算400ms平均值
-		SpeedFltSum += p_MC_SpeedSensorData->Speed_Data;
-		Count++;
-		if(Count >= 8)
-		{
-			*AvgResult = SpeedFltSum >> 3;
-			
-			SpeedFltSum = 0;
-			Count = 0;
-		}
 		PeriodTimeCnt = HAL_GetTick();
 	}
-	
 }

User/Src/tasks.c

@@ -1,6 +1,7 @@
 #include "tasks.h"
 #include "iwdg.h"
 #include "gpio.h"
+#include "tim.h"
 #include "can_process.h"
 #include "uart_process.h"
 #include "eeprom_24c02.h"
@@ -28,6 +29,7 @@ TrueOrFalse_Flag_Struct_t IsInitFinish_Flag = FALSE;
 void HAL_SYSTICK_Callback(void)
 {
 	static uint16_t TimeCnt_10ms = 0;
+	static uint16_t TimeCnt_50ms = 0;
 	static uint16_t TimeCnt_100ms = 0;
 	static uint16_t TimeCnt_1000ms = 0;
 	static uint32_t FaultDelayTime = 0;
@@ -54,7 +56,7 @@ void HAL_SYSTICK_Callback(void)
 	{
 	  FaultDelayTime = HAL_GetTick();
 	}
-	MC_CalParam_Cal(MC_WorkMode, ADC_SensorData, MC_ControlCode.GearSt, IsBreakTrig_Flag, &MC_CalParam);
+	MC_CalParam_Cal(MC_WorkMode, ADC_SensorData, MC_ControlCode.GearSt, IsBreakTrig_Flag, IsGearSensorTrig_Flag, &MC_CalParam);
 	
 	//更新控制参数备份值
 	Update_MC_CalParam_Back();
@@ -73,6 +75,15 @@ void HAL_SYSTICK_Callback(void)
 
 	}
 	
+	//50ms任务
+	TimeCnt_50ms++;
+	if(TimeCnt_50ms >= 50)
+	{
+	  TimeCnt_50ms = 0;
+		//计算TE同步时钟频率
+    Cal_SyncClockFreq(&MC_TE_SyncClockFreqScan);
+	}
+	
 	//100ms任务
 	TimeCnt_100ms++;
 	if(TimeCnt_100ms >= 100)
@@ -137,7 +148,7 @@ void MC_RunInfo_Update(void)
 		//续航里程
 		MC_RunInfo.RemainDistance = RemainDis.remainDistance;
 		
-		//总里程计算
+		//骑行总里程计算
 		static uint32_t WheelTurnCount  = 0;
 		if((MC_SpeedSensorData.WheelTurnCount - WheelTurnCount) >= (10000 / MC_ConfigParam.WheelSize)) // 统计单位0.1km
 		{	  
@@ -147,6 +158,31 @@ void MC_RunInfo_Update(void)
 			WheelTurnCount = MC_SpeedSensorData.WheelTurnCount;
 		}
 		
+		//骑行总时间计算
+	  static uint8_t Period_1sCnt = 0;
+		static uint16_t SavePeriod_Cnt = 0;
+		if(MC_RunInfo.BikeSpeed >= 30)
+		{
+		  Period_1sCnt++;
+			if(Period_1sCnt >= 5)  //运行周期为200ms，计时周期200 * 5 = 1s
+			{
+			  Period_1sCnt = 0;
+				MC_RunInfo.ODO_Time++;
+				MC_RunLog.ODO_Time++;
+				SavePeriod_Cnt++;
+			}
+		}
+		else
+		{
+		  Period_1sCnt = 0;
+		}
+		//存储骑行总时间
+		if(SavePeriod_Cnt >= 60)  //累计骑行60s进行存储
+		{
+		  SavePeriod_Cnt = 0;
+			SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RUN_LOG, sizeof(MC_RunLog_Struct_t), (uint8_t*)&MC_RunLog.PowerOnCnt);
+		}		
+		
 		//平均功耗
 		MC_RunInfo.PowerPerKm = RemainDis.Power_per_km_result / 10;
 		
@@ -270,7 +306,7 @@ void MC_TE_SensorData_Process(uint16_t Speed, MC_TE_SensorData_Struct_t* p_MC_TE
 	  p_MC_TE_SensorData->SpeedSensorTrigCnt++;
 	}
 	SpeedSensor = GPIO_PinState_Temp;
-	//电机转速值
+	//同步时钟频率
 	p_MC_TE_SensorData->SynC_Clock_Freq = 1000; //1000KHz
 	
 	//数据发送
@@ -372,10 +408,10 @@ void PowerOff_Process(void)
 	SendData(ID_MC_BC, MODE_REPORT, 0x1305, (uint8_t*)"READY");
 }
 
-//CAN设备通信状态检测处理
-void MC_CanRxCheck_Process(MC_WorkMode_Struct_t WorkMode, MC_GearSt_Struct_t* GearSt)
+//CAN设备PBU通信状态检测处理
+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)
 {
-  if(WorkMode == MC_WorkMode_Run)
+  if((WorkMode == MC_WorkMode_Run) && (NoPBU_Flag == MC_SUPPORT_DISABLE)) //不支持无PBU，且正常运行模式
 	{
 		//PBU通信状态检测
 		if(IsComOK_PBU.IsOK_Flag == TRUE)
@@ -385,22 +421,69 @@ void MC_CanRxCheck_Process(MC_WorkMode_Struct_t WorkMode, MC_GearSt_Struct_t* Ge
 				IsComOK_PBU.IsOK_Flag = FALSE;
 				*GearSt = MC_GearSt_OFF;
         Update_MC_ControlCode_Back();
+				DeviceOnLine_Status.Status_Bit.PBU_OffLine = 1;
+			}
+			else
+			{
+			  DeviceOnLine_Status.Status_Bit.PBU_OffLine = 0;
 			}
 		}		
 		else
 		{
 		  *GearSt = MC_GearSt_OFF;
       Update_MC_ControlCode_Back();
+			DeviceOnLine_Status.Status_Bit.PBU_OffLine = 1;
+		}
+		
+		//HMI通信状态检测
+		if(NoHMI_Flag == MC_SUPPORT_ENABLE)
+		{
+		  DeviceOnLine_Status.Status_Bit.HMI_OffLine = 0;
+		}
+		else
+		{
+		  if(IsComOK_HMI.IsOK_Flag == TRUE)
+			{
+			  if((HAL_GetTick() - IsComOK_HMI.OK_TrigTime) > 1000)  
+			  {  
+			  	IsComOK_HMI.IsOK_Flag = FALSE;
+					DeviceOnLine_Status.Status_Bit.PBU_OffLine = 1;
+			  }
+				else
+				{
+				  DeviceOnLine_Status.Status_Bit.PBU_OffLine = 0;
+				}
+			}
+			else
+			{
+			  DeviceOnLine_Status.Status_Bit.HMI_OffLine = 1;
+			}
+		}
+		
+		//BMS通信状态检测
+		if(IsComOK_BMS.IsOK_Flag == TRUE)
+		{
+			if((HAL_GetTick() - IsComOK_BMS.OK_TrigTime) > 1000)  
+			{  
+				IsComOK_BMS.IsOK_Flag = FALSE;
+				DeviceOnLine_Status.Status_Bit.BMS_OffLine = 1;
+			}
+			else
+			{
+				DeviceOnLine_Status.Status_Bit.BMS_OffLine = 0;
+			}
+		}
+		else
+		{
+			DeviceOnLine_Status.Status_Bit.BMS_OffLine = 1;
 		}
 	}
-
 }
 
 //运行总时间计算
 void MC_RunTime_Cal(uint32_t* p_Runtime)
 {
   static uint32_t PeriodTimeCnt = 0;
-	static uint8_t Count = 0;
 	
 	if((HAL_GetTick()- PeriodTimeCnt) >= 60000)
 	{
@@ -408,12 +491,7 @@ void MC_RunTime_Cal(uint32_t* p_Runtime)
 		
 		(*p_Runtime)++;
 		//存储运行总时间
-		Count++;
-		if(Count >= 5)
-		{
-		  Count = 0;
-			SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RUN_LOG, sizeof(MC_RunLog_Struct_t), (uint8_t*)&MC_RunLog.PowerOnCnt);
-		}
+		SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RUN_LOG, sizeof(MC_RunLog_Struct_t), (uint8_t*)&MC_RunLog.PowerOnCnt);
 	}
 }
 
@@ -502,6 +580,16 @@ void MC_DeviceCheck(MC_ErrorCode_Struct_t* p_ErrorCode)
 	
 	
 	
+}
+
+//计算TIM2 ETR采集频率
+void Cal_SyncClockFreq(uint16_t* Result)
+{
+  uint16_t Count = 0;
+	
+	Count = __HAL_TIM_GET_COUNTER(&htim2);
+  *Result = Count * 20 / 1000;//50ms内计数值，单位转换为KHz
+  __HAL_TIM_SET_COUNTER(&htim2, 0);
 }
 
 /**************************全局函数定义结束*****************/

User/Src/tim.c

@@ -47,6 +47,7 @@
 /* USER CODE END 0 */
 
 TIM_HandleTypeDef htim1;
+TIM_HandleTypeDef htim2;
 TIM_HandleTypeDef htim3;
 
 /* TIM1 init function */
@@ -105,6 +106,40 @@ void MX_TIM1_Init(void)
 
 }
 
+/* TIM2 init function */
+void MX_TIM2_Init(void)
+{
+  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
+  TIM_MasterConfigTypeDef sMasterConfig = {0};
+
+  htim2.Instance = TIM2;
+  htim2.Init.Prescaler = 0;
+  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
+  htim2.Init.Period = 65535;
+  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
+  htim2.Init.RepetitionCounter = 0;
+  htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
+  if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_ETRMODE2;
+  sClockSourceConfig.ClockPolarity = TIM_CLOCKPOLARITY_NONINVERTED;
+  sClockSourceConfig.ClockPrescaler = TIM_CLOCKPRESCALER_DIV1;
+  sClockSourceConfig.ClockFilter = 0;
+  if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
+  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
+  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
+  {
+    Error_Handler();
+  }
+
+}
+
 void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* htim_base)
 {
 
@@ -155,6 +190,30 @@ void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* htim_base)
   /* USER CODE BEGIN TIM1_MspInit 1 */
 
   /* USER CODE END TIM1_MspInit 1 */
+  }
+	
+	else if(htim_base->Instance==TIM2)
+  {
+  /* USER CODE BEGIN TIM2_MspInit 0 */
+
+  /* USER CODE END TIM2_MspInit 0 */
+    /* TIM2 clock enable */
+    __HAL_RCC_TIM2_CLK_ENABLE();
+		
+		__HAL_RCC_GPIOA_CLK_ENABLE();
+    /**TIM2 GPIO Configuration    
+    PA0-WKUP     ------> TIM2_ETR 
+    */
+    GPIO_InitStruct.Pin = GPIO_PIN_0;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
+    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
+
+
+  /* USER CODE BEGIN TIM2_MspInit 1 */
+  
+  /* USER CODE END TIM2_MspInit 1 */
   }
 }
 
@@ -187,6 +246,24 @@ void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef* htim_base)
     HAL_NVIC_DisableIRQ(TIM1_UP_IRQn);
 		HAL_NVIC_DisableIRQ(TIM1_BRK_IRQn);
 
+  }
+	
+	else if(htim_base->Instance==TIM2)
+  {
+  /* USER CODE BEGIN TIM2_MspDeInit 0 */
+
+  /* USER CODE END TIM2_MspDeInit 0 */
+    /* Peripheral clock disable */
+    __HAL_RCC_TIM2_CLK_DISABLE();
+  
+    /**TIM2 GPIO Configuration    
+    PA0-WKUP     ------> TIM2_ETR 
+    */
+    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_0);
+
+  /* USER CODE BEGIN TIM2_MspDeInit 1 */
+
+  /* USER CODE END TIM2_MspDeInit 1 */
   }
   /* USER CODE BEGIN TIM1_MspDeInit 1 */
 

User/Src/uart_process.c

@@ -8,20 +8,20 @@
 //命令处理
 void UART_DataProcess(uint8_t Mode, uint16_t Command, uint8_t* Data)
 {
-//  uint8_t DataLength;
+  uint8_t DataLength;
 	static uint8_t EnterCnt = 0;
 	
 	//通信正常标志
 	IsComOK_TE = TRUE;
 	
 	//命令解析
-//	DataLength = (uint8_t)(Command &0x00FF);
+	DataLength = (uint8_t)(Command &0x00FF);
 	switch(Command)
 	{
 	  case 0x8008:
 		{
 		  //复制TE返回故障码
-			memcpy((uint8_t*)&MC_TE_SensorStatus.TE_ErrorCode, Data, sizeof(MC_TE_SensorStatus));
+			memcpy((uint8_t*)&MC_TE_SensorStatus.TE_ErrorCode, Data, DataLength);
 			//发送同步信号，清零计数
 			EnterCnt++;
 			if(EnterCnt >= 20)

User/Src/var.c

@@ -22,6 +22,7 @@ uint8_t UserString3[16];                                  //MC
 Device_CheckInfo_Struct_t MC_CheckInfo;                   //MC授权信息
 MC_TE_SensorStatus_Struct_t MC_TE_SensorStatus;           //TE传回传感器状态			
 MC_TE_SensorData_Struct_t MC_TE_SensorData;               //发给TE传感器结果
+uint16_t MC_TE_SyncClockFreqScan;                         //TE同步时钟频率
 MC_AssistParam_Struct_t MC_AssisParam;		                //助力输出计算参数
 uint8_t MC_WalkMode_Persent = 100;                        //推行模式最高转速百分比设置
 #if INSERT_FAULT_TEST_FLAG
@@ -209,7 +210,7 @@ const nGearParam_Struct_t GearParam_Default_SPORT_Volans_Plus =
 	(uint16_t)1590,
 	(uint8_t)3,
 	(uint8_t)1,
-	(uint16_t)1003
+	(uint16_t)850
 };
 
 //TURBO档位助力参数
@@ -259,7 +260,7 @@ void Var_Init(void)
 		
 	//MC版本信息初始化，Mode和SN从EEPROM读取
   strncpy(MC_VerInfo.HW_Version, (char*)"V0r5r0_20190610.", 16);//QD007E，增加修改同步IO和同步时钟的跳线，QD004D第二版设计可以引用
-	strncpy(MC_VerInfo.FW_Version, (char*)"V0r2r0_20190723.", 16);
+	strncpy(MC_VerInfo.FW_Version, (char*)"V1r0r0_20190814.", 16);
 	
 	//MC校验信息初始化，校验码从EEPROM读取
 	uint32_t ID_Temp;