motor_ctl-2/User/Src/fault_check.c

#include "fault_check.h"
#include "math_tools.h"
#include "motor_control.h"
#include "speed_sensor.h"
#include "usart.h"
#include "can.h"
#include "MC_FOC_Driver.h"
#include "MC_Globals.h"
#include "eeprom_24c02.h"
#include "eeprom_Flash.h"
#include "log_save.h"

/*********************************局部函数定义*****************************/
//速度传感器故障检测
void MC_Fault_SpeedSensor_Process(TrueOrFalse_Flag_Struct_t IsStopFlag, MC_CadenceResult_Struct_t CadenceSensor, uint16_t MotorSpeed, MC_AssistRunMode_Struct_t AssistRunMode, MC_ErrorCode_Struct_t* p_MC_ErrorCode)
{
  static uint32_t TrigTimeCnt_1 = 0;
	static uint32_t TrigTimeCnt_2 = 0;
	uint16_t DelayTime = 0;
		
	if(p_MC_ErrorCode->ERROR_Bit.Fault_SpeedSensor == 0)
	{
		if(AssistRunMode == MC_AssistRunMode_INVALID)
		{
	  	TrigTimeCnt_1 = HAL_GetTick();
			TrigTimeCnt_2 = HAL_GetTick();
		}
		//推行助力模式下，检测速度传感器是否产生信号变化
		else if( (AssistRunMode == MC_AssistRunMode_WALK)||(AssistRunMode == MC_AssistRunMode_GAS) )
		{
		  if((MotorSpeed > 50) && (IsStopFlag == TRUE))
			{ 
			  DelayTime = 4125000 / MotorSpeed;//考虑前后齿比为0.8的情况下，轮子转一圈的时间为：60 / (电机转速 / (4.55 * 2.4) * 0.8) s, 延长5圈时间
				DelayTime = DelayTime < 10000 ? 10000 : DelayTime;
				if((HAL_GetTick() - TrigTimeCnt_1) > DelayTime)
				{
				  p_MC_ErrorCode->ERROR_Bit.Fault_SpeedSensor = 1;
					//记录故障日志
					MC_ErrorLogSaveInfo.NotesInfo1 = 1;
					ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
					IsErrorLogSaveInfoUpdateFlag = TRUE;
					//存储故障次数
					MC_RunLog1.SPS_FaultCnt++;
					RunLogSaveIndex = 1;
							
					return;
				}
			}
			else
			{
			  TrigTimeCnt_1 = HAL_GetTick();
			}
		}
		//骑行状态下，检测速度传感器是否产生信号变化
		else
		{
			if((CadenceSensor.Cadence_Data >= 5) && (CadenceSensor.Cadence_Dir == MC_Cadence_Forward) && (IsStopFlag == TRUE))
			{
				DelayTime = 375000 / CadenceSensor.Cadence_Data;//考虑前后齿比为0.8的情况下，轮子转一圈的时间为：60 / (踏频 * 0.8) s, 延长5圈时间
				DelayTime = DelayTime < 10000 ? 10000 : DelayTime;
				if((HAL_GetTick() - TrigTimeCnt_2) > DelayTime)
				{
					p_MC_ErrorCode->ERROR_Bit.Fault_SpeedSensor = 1;
					//记录故障日志
					MC_ErrorLogSaveInfo.NotesInfo1 = 2;
					ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
					IsErrorLogSaveInfoUpdateFlag = TRUE;
					//存储故障次数
					MC_RunLog1.SPS_FaultCnt++;
					RunLogSaveIndex = 1;
					
					return;
				}
			}
			else
			{
				TrigTimeCnt_2 = HAL_GetTick();
			}
		}
	}
}

//力矩传感器故障检测
typedef struct
{
	uint32_t TrigTimeCnt_1;
	uint32_t TrigTimeCnt_2;
	uint16_t TorqueArray[25];
	uint16_t FaultType;
	uint32_t DiffStdResult;
}ToruqeSensorFaultCheck_Struct_t;

//单个力矩传感器故障检测
void MC_Fault_TorqueSensor_Process_Single(uint16_t ADC_Data, uint8_t Num, ToruqeSensorFaultCheck_Struct_t* p_SensorCheck, uint8_t Cadence,
	                                        TorsueSensorFaultStatus_Struct_t* SensorFaultStatus)
{
	uint16_t i;
//	uint16_t DelayTime;

	for(i=0; i<(sizeof(p_SensorCheck->TorqueArray) / 2 - 1); i++)
	{
		p_SensorCheck->TorqueArray[i] = p_SensorCheck->TorqueArray[i + 1];
	}
	p_SensorCheck->TorqueArray[sizeof(p_SensorCheck->TorqueArray) / 2 - 1] = ADC_Data;

	p_SensorCheck->DiffStdResult = GetStandardDeviation(p_SensorCheck->TorqueArray, sizeof(p_SensorCheck->TorqueArray) / 2);
	//标准差较小
	if(p_SensorCheck->DiffStdResult < 10)
	{
//		DelayTime = 120000 / Cadence;  //根据踏频计算踩踏2圈的时间，要考虑空踩情况
//		DelayTime = (DelayTime < 250) ? 250 : DelayTime;
		if((HAL_GetTick() - p_SensorCheck->TrigTimeCnt_1) > 15000)
		{
			SensorFaultStatus->FaultStatusCode |= 1 << (Num - 1);
			p_SensorCheck->FaultType = 1;
			return;
		}
	}
	else
	{
		p_SensorCheck->TrigTimeCnt_1 = HAL_GetTick();
	}
	
	//传感器短路或开路检测
	if((ADC_Data < 50) || (ADC_Data > 4050))
	{
		if((HAL_GetTick() - p_SensorCheck->TrigTimeCnt_2) > 1000)
		{
			SensorFaultStatus->FaultStatusCode |= 1 << (Num - 1);
			p_SensorCheck->FaultType = 2;
			return;
		}
	}
	else
	{
		p_SensorCheck->TrigTimeCnt_2 = HAL_GetTick();
	}
}

//力矩传感器故障综合检测
void MC_Fault_TorqueSensor_Process(uint16_t* SensorData, 
	                                 MC_GearSt_Struct_t GearSt, MC_CadenceResult_Struct_t CadenceData, MC_AssistRunMode_Struct_t AstMode, 
                                   TorsueSensorFaultStatus_Struct_t* SensorFaultStatus, MC_ErrorCode_Struct_t* p_MC_ErrorCode)
{
	static uint32_t PeriodTimeCnt = 0;
	
	static ToruqeSensorFaultCheck_Struct_t ToruqeSensorFaultCheck_Struct_t[3]; //用于传感器1\2\3的判断
		
	if((HAL_GetTick() < 5000) || (MC_WorkMode == MC_WorkMode_Config) || (MC_WorkMode == MC_WorkMode_Debug))
	{	  
		ToruqeSensorFaultCheck_Struct_t[0].TrigTimeCnt_1 = HAL_GetTick();
		ToruqeSensorFaultCheck_Struct_t[0].TrigTimeCnt_2 = HAL_GetTick();
		ToruqeSensorFaultCheck_Struct_t[1].TrigTimeCnt_1 = HAL_GetTick();
		ToruqeSensorFaultCheck_Struct_t[1].TrigTimeCnt_2 = HAL_GetTick();
		ToruqeSensorFaultCheck_Struct_t[2].TrigTimeCnt_1 = HAL_GetTick();
		ToruqeSensorFaultCheck_Struct_t[2].TrigTimeCnt_2 = HAL_GetTick();
	}
	
	//运行周期20ms
	if((HAL_GetTick() - PeriodTimeCnt) >= 20)
	{
		PeriodTimeCnt = HAL_GetTick();
		
		//力矩助力模式、踏频正转且大于30rpm
		if(((GearSt != 0x22) && ((GearSt & 0x0F) != 0)) && (CadenceData.Cadence_Data > 30) && (CadenceData.Cadence_Dir == MC_Cadence_Forward) && (AstMode == MC_AssistRunMode_TORQUE))
		{
		  //判断传感器1
		  MC_Fault_TorqueSensor_Process_Single(SensorData[0], 1, &ToruqeSensorFaultCheck_Struct_t[0], CadenceData.Cadence_Data, SensorFaultStatus);
		
	  	//判断传感器2
		  MC_Fault_TorqueSensor_Process_Single(SensorData[1], 2, &ToruqeSensorFaultCheck_Struct_t[1], CadenceData.Cadence_Data, SensorFaultStatus);
		
		  //判断传感器3
		  MC_Fault_TorqueSensor_Process_Single(SensorData[2], 3, &ToruqeSensorFaultCheck_Struct_t[2], CadenceData.Cadence_Data, SensorFaultStatus);
			
		}	
		else
		{
			ToruqeSensorFaultCheck_Struct_t[0].TrigTimeCnt_1 = HAL_GetTick();
			ToruqeSensorFaultCheck_Struct_t[0].TrigTimeCnt_2 = HAL_GetTick();
			ToruqeSensorFaultCheck_Struct_t[1].TrigTimeCnt_1 = HAL_GetTick();
			ToruqeSensorFaultCheck_Struct_t[1].TrigTimeCnt_2 = HAL_GetTick();
			ToruqeSensorFaultCheck_Struct_t[2].TrigTimeCnt_1 = HAL_GetTick();
			ToruqeSensorFaultCheck_Struct_t[2].TrigTimeCnt_2 = HAL_GetTick();
		}
	}

	//综合判断
	if(p_MC_ErrorCode->ERROR_Bit.Fault_TorqueSensor == 0)
	{
	  if((SensorFaultStatus->FaultBit.Sensor1 + SensorFaultStatus->FaultBit.Sensor2 + SensorFaultStatus->FaultBit.Sensor3) > 2)//超过3个传感器异常
		{
		  p_MC_ErrorCode->ERROR_Bit.Fault_TorqueSensor = 1;
			//记录故障日志
			MC_ErrorLogSaveInfo.NotesInfo1 = (SensorFaultStatus->FaultStatusCode << 8);    //高8位存储3个传感器的故障状态
			MC_ErrorLogSaveInfo.NotesInfo1 |= (ToruqeSensorFaultCheck_Struct_t[0].FaultType) + 
			                                  (ToruqeSensorFaultCheck_Struct_t[1].FaultType << 2) +
			                                  (ToruqeSensorFaultCheck_Struct_t[2].FaultType << 4);   //依次存储3个传感器的故障类型
			MC_ErrorLogSaveInfo.NotesInfo2 = (ToruqeSensorFaultCheck_Struct_t[0].DiffStdResult) +    //依次存储传感器1、2的标准差
			                                 (ToruqeSensorFaultCheck_Struct_t[1].DiffStdResult << 8);
			MC_ErrorLogSaveInfo.NotesInfo3 = (ToruqeSensorFaultCheck_Struct_t[2].DiffStdResult);     //存储传感器3的标准差
			ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
			IsErrorLogSaveInfoUpdateFlag = TRUE;	
			//存储故障次数
			MC_RunLog1.TQS_FaultCnt++;
			RunLogSaveIndex = 1;
			return;
		}
	}
}

//缺相检测
void MC_Fault_PhaseLine_Process(FlagStatus Foc_Flag, uint16_t BusCurrent, uint16_t MotorSpeed, ADC_3ShuntCurrent_Struct_t Phase_Current, MC_ErrorCode_Struct_t* p_MC_ErrorCode)
{
  static uint32_t TrigTimeCnt_PhaseA = 0;
	static uint32_t TrigTimeCnt_PhaseB = 0;
	static uint32_t TrigTimeCnt_PhaseC = 0;
	
	if(p_MC_ErrorCode->ERROR_Bit.Fault_PhaseLine == 0)
	{
	  if((Foc_Flag == SET) && (BusCurrent > 5000) && (MotorSpeed > 500))
		{
		  //A相电流
			if(abs(Phase_Current.uw_phase_a) < 300)
			{
			  if((HAL_GetTick() - TrigTimeCnt_PhaseA) > 5000)
				{
		  		p_MC_ErrorCode->ERROR_Bit.Fault_PhaseLine = 1;
					//记录故障日志
					MC_ErrorLogSaveInfo.NotesInfo1 = 1;
					MC_ErrorLogSaveInfo.NotesInfo2 = abs(Phase_Current.uw_phase_a);
					ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
					IsErrorLogSaveInfoUpdateFlag = TRUE;
					//存储故障次数
					MC_RunLog1.PhaseLine_FaultCnt++;
			  	RunLogSaveIndex = 1;
					
					return;
				}
			}
			else
			{
			  TrigTimeCnt_PhaseA = HAL_GetTick();
			}
			//B相电流
			if(abs(Phase_Current.uw_phase_b) < 300)
			{
			  if((HAL_GetTick() - TrigTimeCnt_PhaseB) > 5000)
				{
		  		p_MC_ErrorCode->ERROR_Bit.Fault_PhaseLine = 1;
					//记录故障日志
					MC_ErrorLogSaveInfo.NotesInfo1 = 2;
					MC_ErrorLogSaveInfo.NotesInfo2 = abs(Phase_Current.uw_phase_b);
					ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
					IsErrorLogSaveInfoUpdateFlag = TRUE;
					//存储故障次数
					MC_RunLog1.PhaseLine_FaultCnt++;
			  	RunLogSaveIndex = 1;		
					
					return;
				}
			}
			else
			{
			  TrigTimeCnt_PhaseB = HAL_GetTick();
			}
			//C相电流
			if(abs(Phase_Current.uw_phase_c) < 300)
			{
			  if((HAL_GetTick() - TrigTimeCnt_PhaseC) > 5000)
				{
		  		p_MC_ErrorCode->ERROR_Bit.Fault_PhaseLine = 1;
					//记录故障日志
					MC_ErrorLogSaveInfo.NotesInfo1 = 3;
					MC_ErrorLogSaveInfo.NotesInfo2 = abs(Phase_Current.uw_phase_c);
					ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
					IsErrorLogSaveInfoUpdateFlag = TRUE;
					//存储故障次数
					MC_RunLog1.PhaseLine_FaultCnt++;
			  	RunLogSaveIndex = 1;
					
					return;
				}
			}
			else
			{
			  TrigTimeCnt_PhaseC = HAL_GetTick();
			}
		}
		else
		{
		  TrigTimeCnt_PhaseA = HAL_GetTick();
			TrigTimeCnt_PhaseB = HAL_GetTick();
			TrigTimeCnt_PhaseC = HAL_GetTick();
		}
	}
}

//温度传感器故障检测
void MC_Fault_NTCSensor_Process(uint8_t T_PCB_Result, uint8_t T_Coil_Result, MC_ErrorCode_Struct_t* p_MC_ErrorCode)
{
  static uint32_t TrigTimeCnt_PCB = 0;         //PCB NTC采集异常计时
	static uint32_t TrigTimeCnt_Coil = 0;        //绕组 NTC采集异常计时
//	static uint32_t NTC_Check_PeriodTimeCnt = 0; //NTC检测，母线电流采集周期
//	static uint16_t NTC_Check_Count = 0;
//	static uint32_t BusCurrentSum = 0;
//	static uint16_t BusCurrentAvg1 = 0, BusCurrentAvg2 = 0;
//	static uint8_t T_PCB_Old = 0;
//	static uint8_t T_Coil_Old = 0;
		
	//初始化5s，且50度以上，不检测NTC故障
	if((HAL_GetTick() < 5000) || (T_PCB_Result > 90))
	{
	  TrigTimeCnt_PCB = HAL_GetTick();
		TrigTimeCnt_PCB = HAL_GetTick();
//		NTC_Check_PeriodTimeCnt = HAL_GetTick();
//		NTC_Check_Count = 0;
//		
//		T_PCB_Old = T_PCB_Result;
//		T_Coil_Old = T_Coil_Result;
		
		return;
	}
	
	if(p_MC_ErrorCode->ERROR_Bit.Fault_NtcSensor == 0)
	{
	  //PCB上NTC短路或开路检测，判断AD值是否为异常值
	  if((T_PCB_Result < 5) || (T_PCB_Result > 190))           //5(-35度):AD为4000，180(140度):AD为80
		{
			if((HAL_GetTick() - TrigTimeCnt_PCB) > 5000)
			{
				p_MC_ErrorCode->ERROR_Bit.Fault_NtcSensor = 1;
				//记录故障日志
				MC_ErrorLogSaveInfo.NotesInfo1 = 1;
				MC_ErrorLogSaveInfo.NotesInfo2 = T_PCB_Result;
				MC_ErrorLogSaveInfo.NotesInfo3 = T_Coil_Result;
				ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
				IsErrorLogSaveInfoUpdateFlag = TRUE;
				//存储故障次数
				MC_RunLog1.NTC_FaultCnt++;
			  RunLogSaveIndex = 1;	
				
				return;
			}
		}
		else
		{
	  	TrigTimeCnt_PCB = HAL_GetTick();
		}
		
	  //NTC短路或开路检测，判断AD值是否为异常值
		if((T_Coil_Result < 5) || (T_Coil_Result > 190))    //5(-35度):AD为4000，180(140度):AD为80
		{
			if((HAL_GetTick() - TrigTimeCnt_Coil) > 5000)
			{
				p_MC_ErrorCode->ERROR_Bit.Fault_NtcSensor = 1;
				//记录故障日志
				MC_ErrorLogSaveInfo.NotesInfo1 = 2;
				MC_ErrorLogSaveInfo.NotesInfo2 = T_PCB_Result;
				MC_ErrorLogSaveInfo.NotesInfo3 = T_Coil_Result;				
				ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
				IsErrorLogSaveInfoUpdateFlag = TRUE;
				//存储故障次数
				MC_RunLog1.NTC_FaultCnt++;
			  RunLogSaveIndex = 1;
				
				return;
			}
		}
		else
		{
		  TrigTimeCnt_Coil = HAL_GetTick();
		}
		
//		//NTC为固定值的检测，分别计算2个6.8min内母线电流平均值，当两段母线电流平均值不相等时判断NTC是否发生变化
//		if((HAL_GetTick() - NTC_Check_PeriodTimeCnt) >= 100)
//		{
//			NTC_Check_PeriodTimeCnt = HAL_GetTick();
//			BusCurrentSum += (uint16_t)((MC_RunInfo.BusCurrent > 20000) ? 156 
//																 : MC_RunInfo.BusCurrent >> 7);//按照mA / 128 判断,约0.1A,限幅20A
//			NTC_Check_Count++;
//			if(NTC_Check_Count == 4096) //计算第一个6.8min平均值
//			{
//					//avg1 = (x1 + x2 + ... + x4096) / 4096
//					BusCurrentAvg1 = BusCurrentSum >> 12; 
//			}
//			else if(NTC_Check_Count >= 8192) //第二个6.8min
//			{
//					NTC_Check_Count = 0;
//					//avg2 = (x4097 + x4098 + ... +x8192) / 4096 = 2 * (x1 + x2 + ... + x8192) / 8192 - avg1
//					BusCurrentAvg2 = (BusCurrentSum >> 12) - BusCurrentAvg1; 
//					BusCurrentSum = 0;
//					//总平均电流超过10A时，当两段平均电流变化超过3A，判断温度是否发生变化
//					if(((BusCurrentAvg1 + BusCurrentAvg2) >> 1) > 79) //79 * 128 = 10.1A
//					{
//							if(abs(BusCurrentAvg1 - BusCurrentAvg2) >= 25)  //25 * 128 = 3.2A
//							{
//									if((abs(T_PCB_Result - T_PCB_Old) < 1) ||  //PCB 温升小于1度
//										 (abs(T_Coil_Result - T_Coil_Old) < 1))  //绕组温升小于1度
//									{
//											p_MC_ErrorCode->ERROR_Bit.Fault_NtcSensor = 1;
//											//记录故障日志
//											MC_ErrorLogSaveInfo.NotesInfo1 = 3;
//											MC_ErrorLogSaveInfo.NotesInfo2 = (BusCurrentAvg1 << 8) + (BusCurrentAvg2);
//											MC_ErrorLogSaveInfo.NotesInfo3 = (uint16_t)((abs(T_PCB_Result - T_PCB_Old) << 8) 
//																																+ (abs(T_Coil_Result - T_Coil_Old) < 2));
//											ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
//											IsErrorLogSaveInfoUpdateFlag = TRUE;
//											//存储故障次数
//											MC_RunLog1.NTC_FaultCnt++;
//											RunLogSaveIndex = 1;    
//											return;
//								 }
//							}
//					}
//					T_PCB_Old = T_PCB_Result;
//					T_Coil_Old = T_Coil_Result;
//			}
//		}		
	}
}

//指拨故障检测
void MC_Fault_GasSensor_Process(uint16_t ADC_Data, MC_ErrorCode_Struct_t* p_MC_ErrorCode)
{
  //开路检测
	//...
	
	//短路检测
	//...
}

//MOS短路检测
void MC_Fault_MOS_Process(ADC_3ShuntCurrent_Struct_t ShuntCurrent, MC_ErrorCode_Struct_t* p_MC_ErrorCode)
{
  static uint32_t TrigTimeCnt_A = 0;
	static uint32_t TrigTimeCnt_B = 0;
	static uint32_t TrigTimeCnt_C = 0;
	
	if(FOC_Status != FOC_Status_RUN)
	{
	  TrigTimeCnt_A = HAL_GetTick();
		TrigTimeCnt_B = HAL_GetTick();
		TrigTimeCnt_C = HAL_GetTick();
		return;
	}
	
	if(p_MC_ErrorCode->ERROR_Bit.Fault_MOS == 0)
	{
	  //A相MOS短路
		if(abs(ShuntCurrent.uw_phase_a) > 20000)
		{
		  if((HAL_GetTick() - TrigTimeCnt_A) > 1000)
			{
			  p_MC_ErrorCode->ERROR_Bit.Fault_MOS = 1;
				//记录故障日志
				MC_ErrorLogSaveInfo.NotesInfo1 = 1;
				MC_ErrorLogSaveInfo.NotesInfo2 = abs(ShuntCurrent.uw_phase_a);
				ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
				IsErrorLogSaveInfoUpdateFlag = TRUE;
				//存储故障次数
				MC_RunLog2.MOS_ShortCircuit_FaultCnt++;
				RunLogSaveIndex = 2;
				
				return;
			}
		}
		else
		{
		  TrigTimeCnt_A = HAL_GetTick();
		}
		//B相MOS短路
		if(abs(ShuntCurrent.uw_phase_b) > 20000)
		{
		  if((HAL_GetTick() - TrigTimeCnt_B) > 1000)
			{
			  p_MC_ErrorCode->ERROR_Bit.Fault_MOS = 1;
				//记录故障日志
				MC_ErrorLogSaveInfo.NotesInfo1 = 2;
				MC_ErrorLogSaveInfo.NotesInfo2 = abs(ShuntCurrent.uw_phase_b);
				ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
				IsErrorLogSaveInfoUpdateFlag = TRUE;
				//存储故障次数
				MC_RunLog2.MOS_ShortCircuit_FaultCnt++;
				RunLogSaveIndex = 2;
				
				return;
			}
		}
		else
		{
		  TrigTimeCnt_B = HAL_GetTick();
		}
		//C相MOS短路
		if(abs(ShuntCurrent.uw_phase_c) > 20000)
		{
		  if((HAL_GetTick() - TrigTimeCnt_C) > 1000)
			{
			  p_MC_ErrorCode->ERROR_Bit.Fault_MOS = 1;
				//记录故障日志
				MC_ErrorLogSaveInfo.NotesInfo1 = 3;
				MC_ErrorLogSaveInfo.NotesInfo2 = abs(ShuntCurrent.uw_phase_c);
				ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
				IsErrorLogSaveInfoUpdateFlag = TRUE;
				//存储故障次数
				MC_RunLog2.MOS_ShortCircuit_FaultCnt++;
				RunLogSaveIndex = 2;
				
				return;
			}
		}
		else
		{
		  TrigTimeCnt_C = HAL_GetTick();
		}
	}
}

//TE故障检测
void MC_Fault_TE_Process(MC_TE_SensorStatus_Struct_t* p_MC_TE_SensorStatus, TrueOrFalse_Flag_Struct_t ComOK_Flag, MC_ErrorCode_Struct_t* p_MC_ErrorCode)
{	
	static uint8_t ErrorCount_TE_Circuit = 0;
	static uint8_t ErrorCount_MCU = 0;
	static uint8_t ErrorCount_TE_MCU = 0;
	static FlagStatus Fault_TE_MCU_Com_Flag = RESET;
  static FlagStatus Fault_TE_MCU_Soft_Flag = RESET;	
	
	//开机前5s不检测
	if(HAL_GetTick() < 5000)
	{
	  return;
	}
	
	//TE通讯故障超时判断
	static FlagStatus SaveFlag1 = RESET;
	if(ComOK_Flag == FALSE)                                                     
	{
		p_MC_ErrorCode->ERROR_Bit.Fault_TE_MCU = 1;
		if(SaveFlag1 == RESET)
		{
			//记录故障日志
			MC_ErrorLogSaveInfo.NotesInfo1 = 1;
			ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
			IsErrorLogSaveInfoUpdateFlag = TRUE;
			//存储故障次数
			MC_RunLog2.TE_MCU_FaultCnt++;
		  RunLogSaveIndex = 2;
			
			SaveFlag1 = SET;
			Fault_TE_MCU_Com_Flag = SET;
		}
	}
	else
	{
	  Fault_TE_MCU_Com_Flag = RESET;
		SaveFlag1 = RESET;
	}
	
	if(TE_MCU_DataRefreshFlag == TRUE)  //TE发送数据周期500ms
	{
		//TE电路故障异常判断，存在TE与主控采集值差异较大(故障位bit0-9)，或主MCU工作电压大于4.2V
		static FlagStatus SaveFlag2 = RESET;
		if(((p_MC_TE_SensorStatus->TE_ErrorCode.Code & 0x03FF) != 0) || (p_MC_TE_SensorStatus->MCU_Voltage > 4200))
		{
			ErrorCount_TE_Circuit++;
			if(ErrorCount_TE_Circuit >= 5)
			{
				ErrorCount_TE_Circuit = 0;
				p_MC_ErrorCode->ERROR_Bit.Fault_TE_Circuit = 1;
				if(SaveFlag2 == RESET)
				{
					//记录故障日志
				  MC_ErrorLogSaveInfo.NotesInfo1 = 2;
					MC_ErrorLogSaveInfo.NotesInfo2 = p_MC_TE_SensorStatus->TE_ErrorCode.Code;
					MC_ErrorLogSaveInfo.NotesInfo3 = p_MC_TE_SensorStatus->MCU_Voltage;
					ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
				  IsErrorLogSaveInfoUpdateFlag = TRUE;	
					//存储故障次数
					MC_RunLog2.TE_Circuit_FaultCnt++;
				  RunLogSaveIndex = 2;
          
					SaveFlag2 = SET;				
				}				
			}
		}
		//TE电路故障异常恢复判断
		else if(((p_MC_TE_SensorStatus->TE_ErrorCode.Code & 0x03FF) == 0) && (p_MC_TE_SensorStatus->MCU_Voltage < 3600))
		{
			p_MC_ErrorCode->ERROR_Bit.Fault_TE_Circuit = 0;
			ErrorCount_TE_Circuit = 0;
			SaveFlag2 = RESET;
		}
		
		//主控MCU异常判断，主控发送TE的数据超时或时钟频率异常
		static FlagStatus SaveFlag3 = RESET;
		if(((p_MC_TE_SensorStatus->TE_ErrorCode.Code & 0x0C00) != 0))
		{
			ErrorCount_MCU++;
			if(ErrorCount_MCU >= 5)
			{
				ErrorCount_MCU = 0;
				p_MC_ErrorCode->ERROR_Bit.Fault_MCU = 1;
				if(SaveFlag3 == RESET)
				{
					//记录故障日志
			  	MC_ErrorLogSaveInfo.NotesInfo1 = 3;
					MC_ErrorLogSaveInfo.NotesInfo2 = p_MC_TE_SensorStatus->TE_ErrorCode.Code;
					ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
			  	IsErrorLogSaveInfoUpdateFlag = TRUE;	
					//存储故障次数
					MC_RunLog2.MCU_FaultCnt++;
				  RunLogSaveIndex = 2;
          
					SaveFlag3 = SET;			
				}
			}
		}
		//主控MCU异常恢复判断
		else if((p_MC_TE_SensorStatus->TE_ErrorCode.Code & 0x0C00) == 0)
		{
			p_MC_ErrorCode->ERROR_Bit.Fault_MCU = 0;
			ErrorCount_MCU = 0;
			SaveFlag3 = RESET;
		}
			
		//TE MCU异常判断，TE时钟频率异常或TE检测的MCU故障位置位
		static FlagStatus SaveFlag4 = RESET;
		if(   ((MC_TE_SyncClockFreqScan < (p_MC_TE_SensorStatus->SyncClockFreq - 200)) || (MC_TE_SyncClockFreqScan > (p_MC_TE_SensorStatus->SyncClockFreq + 200)))    //TE发送的时钟频率超限
			 || ((p_MC_TE_SensorStatus->TE_ErrorCode.Code & 0x1000) != 0)                 //TE MCU异常
			)
		{
			ErrorCount_TE_MCU++;
			if(ErrorCount_TE_MCU >= 5)
			{
				ErrorCount_TE_MCU = 0;
				p_MC_ErrorCode->ERROR_Bit.Fault_TE_MCU = 1;
				if(SaveFlag4 == RESET)
				{
					//记录故障日志
			  	MC_ErrorLogSaveInfo.NotesInfo1 = 4;
					MC_ErrorLogSaveInfo.NotesInfo2 = p_MC_TE_SensorStatus->TE_ErrorCode.Code;
					MC_ErrorLogSaveInfo.NotesInfo3 = MC_TE_SyncClockFreqScan;
					ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
				  IsErrorLogSaveInfoUpdateFlag = TRUE;	
					//存储故障次数
					MC_RunLog2.TE_MCU_FaultCnt++;
			  	RunLogSaveIndex = 2;
          
					SaveFlag4 = SET;		
          Fault_TE_MCU_Soft_Flag = SET;					
				}
			}
		}
		else
		{
			Fault_TE_MCU_Soft_Flag = RESET;
			ErrorCount_TE_MCU = 0;
			SaveFlag4 = RESET;
		}

		TE_MCU_DataRefreshFlag = FALSE;
	}
	
	//Fault_TE_MCU故障恢复判断
	if((Fault_TE_MCU_Com_Flag == RESET) && (Fault_TE_MCU_Soft_Flag == RESET))//通信正常，且时钟频率正常、TE的MCU微故障检测正常
	{
	  p_MC_ErrorCode->ERROR_Bit.Fault_TE_MCU = 0;
	}
}

//电路故障
void MC_Fault_Circuit_Process(MC_ErrorCode_Struct_t* p_MC_ErrorCode)
{
	static uint32_t PeriodTimeCnt = 0;
	static uint32_t C31_SC_TrigTimeCnt = 0;//C32 短路判断计时
	static uint32_t PowerDriver_TrigTimeCnt = 0; //驱动电源判断计时
	
	//为初始化预留5s
	if(HAL_GetTick() < 5000)
	{
	  PeriodTimeCnt = HAL_GetTick();
		C31_SC_TrigTimeCnt = HAL_GetTick();
		PowerDriver_TrigTimeCnt = HAL_GetTick();
		return;
	}
	
	if(p_MC_ErrorCode->ERROR_Bit.Fault_Circuit == 0)
	{
		//C31(GearSensor)短路检测
		if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_15) == GPIO_PIN_RESET)
		{
			if((HAL_GetTick() - C31_SC_TrigTimeCnt) > 5000)
			{
				p_MC_ErrorCode->ERROR_Bit.Fault_Circuit = 1;
				//记录故障日志
				MC_ErrorLogSaveInfo.NotesInfo1 = 1;
				ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
				IsErrorLogSaveInfoUpdateFlag = TRUE;
				//存储故障次数
				MC_RunLog2.Circuit_FaultCnt++;
				RunLogSaveIndex = 2;
			}
		}
		else
		{
			C31_SC_TrigTimeCnt = HAL_GetTick();
		}
		
		//MOS驱动电源异常检测
		if((MC_TE_SensorStatus.TE_ErrorCode.Code == 0x0000) &&                //TE无故障，未关闭驱动电源
			 (FOC_Status == FOC_Status_RUN) &&                                  //FOC运算启动
			 (MC_CalParam.AssistRunMode != MC_AssistRunMode_INVALID) &&
			 (MC_CalParam.Foc_Flag == SET) &&
			 ((MC_CalParam.Ref_Speed > 200) || (MC_CalParam.Ref_Torque > 200))  //给定值
			)
		{
			if((MC_HallSensorData.IsStopFlag == TRUE) && (MC_RunInfo.BusCurrent < 200))    //电机未启动，0.2A
			{
				if((HAL_GetTick() - PowerDriver_TrigTimeCnt) > 5000)
				{
					p_MC_ErrorCode->ERROR_Bit.Fault_Circuit = 1;
					//记录故障日志
					MC_ErrorLogSaveInfo.NotesInfo1 = 2;
					MC_ErrorLogSaveInfo.NotesInfo2 = MC_TE_SensorStatus.TE_ErrorCode.Code;
					ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
					IsErrorLogSaveInfoUpdateFlag = TRUE;
					//存储故障次数
					MC_RunLog2.Circuit_FaultCnt++;
					RunLogSaveIndex = 2;
				}
			}
			else
			{
				PowerDriver_TrigTimeCnt = HAL_GetTick();
			}
		}
		else
		{
			PowerDriver_TrigTimeCnt = HAL_GetTick();
		}
		
		//以下指令执行周期20ms
		if((HAL_GetTick() - PeriodTimeCnt) >= 20)
		{
			PeriodTimeCnt = HAL_GetTick();
			
			//检测母线电流和相电流是否为异常
			static uint8_t i = 0, CurrentFaultCount = 0;
			static uint32_t BusCurrent_Flt = 0, PhasesCurrentA_Flt = 0, PhasesCurrentB_Flt = 0, PhasesCurrentC_Flt = 0;
			
			BusCurrent_Flt += ADC1_Result_Filt[ADC1_RANK_CURRENT];
			PhasesCurrentA_Flt += ADC2_Result_Filt[ADC2_RANK_CURRENT_A];
			PhasesCurrentB_Flt += ADC2_Result_Filt[ADC2_RANK_CURRENT_B];
			PhasesCurrentC_Flt += ADC2_Result_Filt[ADC2_RANK_CURRENT_C];
			i++;
			if(i >= 32) //计算20 * 32 ms内的平均值
			{
				i = 0;
				
				if((((BusCurrent_Flt >> 5) < 500) || (BusCurrent_Flt >> 5) > 4000) ||                 //母线电流采样异常
					 (((PhasesCurrentA_Flt >> 5) < 5000) || ((PhasesCurrentA_Flt >> 5) > 60000)) ||     //A相电流采样异常
					 (((PhasesCurrentB_Flt >> 5) < 5000) || ((PhasesCurrentB_Flt >> 5) > 60000)) ||     //B相电流采样异常
					 (((PhasesCurrentC_Flt >> 5) < 5000) || ((PhasesCurrentC_Flt >> 5) > 60000))        //C相电流采样异常
					)
				{
					p_MC_ErrorCode->ERROR_Bit.Fault_Circuit = 1;
					//记录故障日志
					MC_ErrorLogSaveInfo.NotesInfo1 = 3;
					ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
					IsErrorLogSaveInfoUpdateFlag = TRUE;
					//存储故障次数
					MC_RunLog2.Circuit_FaultCnt++;
					RunLogSaveIndex = 2;			
				}
				
				if((IqFdbFlt >> 10) > 200) //250时，相电流为9.6A；330时，相电流为12.4A；350时，相电流为13.6A。得到，相电流 = 0.038 * IqFdb
				{
					if(((BusCurrent_Flt >> 5) - uw_current_offset) < 25) //25对应的母线电流约0.6A, DATA / 2048 * 50A
					{
						CurrentFaultCount++;
						if(CurrentFaultCount > 10)
						{
							p_MC_ErrorCode->ERROR_Bit.Fault_Circuit = 1;
							//记录故障日志
							MC_ErrorLogSaveInfo.NotesInfo1 = 4;
							MC_ErrorLogSaveInfo.NotesInfo2 = (BusCurrent_Flt >> 5);
							ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
							IsErrorLogSaveInfoUpdateFlag = TRUE;
							//存储故障次数
							MC_RunLog2.Circuit_FaultCnt++;
							RunLogSaveIndex = 2;
							CurrentFaultCount = 0;
						}
					}
					else
					{
						 CurrentFaultCount = 0;
					}
				}
				else
				{
					CurrentFaultCount = 0;
				}

				BusCurrent_Flt = 0;
				PhasesCurrentA_Flt = 0;
				PhasesCurrentB_Flt = 0;
				PhasesCurrentC_Flt = 0;
			}
					
			//静止状态，检测母线电流和相电流是否随机跳动
			static uint8_t j = 0;
			static uint16_t BusCurrent_Array[50], PhaseCurrentA_Array[50], PhaseCurrentB_Array[50], PhaseCurrentC_Array[50];
			static uint32_t DiffSqrtResult_BusCurrent = 0, DiffSqrtResult_PhaseA = 0, DiffSqrtResult_PhaseB = 0, DiffSqrtResult_PhaseC = 0;
			static uint32_t DelayTimeCnt = 0;
			if((MC_RunInfo.GearSt == 0) && (MC_RunInfo.MotorSpeed == 0))
			{
				if((HAL_GetTick() - DelayTimeCnt) > 5000) // 由运动转为静止5s后进行判断
				{
					BusCurrent_Array[j] = ADC1_Result_Filt[ADC1_RANK_CURRENT];
					PhaseCurrentA_Array[j] = ADC2_Result_Filt[ADC2_RANK_CURRENT_A];
					PhaseCurrentB_Array[j] = ADC2_Result_Filt[ADC2_RANK_CURRENT_B];
					PhaseCurrentC_Array[j] = ADC2_Result_Filt[ADC2_RANK_CURRENT_C];
					j++;
					if(j >= 50)
					{
						j = 0;
						//计算均方差值
						DiffSqrtResult_BusCurrent = GetStandardDeviation(BusCurrent_Array, 50);
						DiffSqrtResult_PhaseA = GetStandardDeviation(PhaseCurrentA_Array, 50);
						DiffSqrtResult_PhaseB = GetStandardDeviation(PhaseCurrentB_Array, 50);
						DiffSqrtResult_PhaseC = GetStandardDeviation(PhaseCurrentC_Array, 50);
						if((DiffSqrtResult_BusCurrent > 500) ||  //母线电流采集异常变化
							 ((DiffSqrtResult_PhaseA > 12000) || (DiffSqrtResult_PhaseB > 12000) || (DiffSqrtResult_PhaseC > 12000))  //相线电流采集异常变化
							)
						{
							p_MC_ErrorCode->ERROR_Bit.Fault_Circuit = 1;
							//记录故障日志
							MC_ErrorLogSaveInfo.NotesInfo1 = 5;
							MC_ErrorLogSaveInfo.NotesInfo2 = DiffSqrtResult_BusCurrent;
							ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
							IsErrorLogSaveInfoUpdateFlag = TRUE;
							//存储故障次数
							MC_RunLog2.Circuit_FaultCnt++;
							RunLogSaveIndex = 2;	
						}
					}
				}
			}
			else
			{
				j = 0;
				DelayTimeCnt = HAL_GetTick();
			}
		}
	}
}


//机械故障
void MC_Fault_Machine_Process(uint16_t MotorSpeed, uint16_t CadenceSpeed, ADC_SensorData_Struct_t SensorData, uint16_t speedratio, MC_ErrorCode_Struct_t* p_MC_ErrorCode)
{
	static uint32_t TimeCount_ClutchFault=0;
	static uint16_t ClutchFaultCount=0;
	
	if( p_MC_ErrorCode->ERROR_Bit.Fault_Machine == 0)  //单向器没有故障时开始检测，有故障后故障一直存在，故障检测不再执行
	{
		if( (HAL_GetTick()-TimeCount_ClutchFault)>=20 )  //20ms执行一次故障判断
		{
			TimeCount_ClutchFault = HAL_GetTick();
			if( (MotorSpeed > 500)&&(CadenceSpeed >= 15)&&(SensorData.TorqueSensor > 200)&&(SensorData.GasSensor < 50) )
			{
				if( speedratio > 1500 ) 
				{
					ClutchFaultCount++;
					if( ClutchFaultCount>= 250)                  //速比连续出错50次判断为故障，时间将近5s
					{
						ClutchFaultCount=0;
						p_MC_ErrorCode->ERROR_Bit.Fault_Machine = 1;
						//记录故障日志
						MC_ErrorLogSaveInfo.NotesInfo1 = 0;       //单向器打滑故障
						MC_ErrorLogSaveInfo.NotesInfo2 = SensorData.TorqueSensor;
						MC_ErrorLogSaveInfo.NotesInfo3 = SensorData.GasSensor;
						ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
						IsErrorLogSaveInfoUpdateFlag = TRUE;
						//存储故障次数
						MC_RunLog2.VoltageChangeOrOverSpeed_FaultCnt++; //和电压异常波动记录复用
						RunLogSaveIndex = 2;
					}
				}
				else 
				{
					ClutchFaultCount=0;			
				}					
			}
			else
			{
				ClutchFaultCount=0;
			}
		}
	}
}




//硬件识别故障
void MC_Fault_Hardware_Identify(TrueOrFalse_Flag_Struct_t TEComOKFlag, uint16_t SyncClockFreqScan, uint16_t Hardware_AD, TrueOrFalse_Flag_Struct_t *inverterExistFlag, MC_ErrorCode_Struct_t* p_MC_ErrorCode)
{
	static uint32_t TimeCount_HardwareFault=0;
	static uint8_t HardwareFaultCount=0, HardwareFaultCount2=0;

	if( HAL_GetTick() < 4000) return; //开机4s后开始检测
	else if( HAL_GetTick() < 10000)   //开机4s到10s时间内检测
	{
		if( p_MC_ErrorCode->ERROR_Bit.Fault_Circuit == 0)  //没有故障时开始检测，有故障后故障一直存在，故障检测不再执行
		{
			if( (HAL_GetTick()-TimeCount_HardwareFault)>=20 )  //20ms执行一次故障判断
			{
				TimeCount_HardwareFault = HAL_GetTick();
				if(*inverterExistFlag == TRUE) //电路板有反相器和TE，认为是旧电路板
				{
					if( ((TEComOKFlag == TRUE)||(SyncClockFreqScan>200))&&((Hardware_AD>1986)&&(Hardware_AD<2110)) ) 
					{
						HardwareFaultCount=0;	
					}
					else //旧电路板电阻焊错导致电压不在1.65V左右，或者新电路板电阻焊错导致电压在1.65V左右
					{
						HardwareFaultCount++;
						if( HardwareFaultCount>= 250)                  
						{
							HardwareFaultCount = 0;
							p_MC_ErrorCode->ERROR_Bit.Fault_Circuit = 1;
							//记录故障日志
							MC_ErrorLogSaveInfo.NotesInfo1 = 8;       
							MC_ErrorLogSaveInfo.NotesInfo2 = (SyncClockFreqScan<<2)+TEComOKFlag;
							MC_ErrorLogSaveInfo.NotesInfo3 = Hardware_AD;
							ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
							IsErrorLogSaveInfoUpdateFlag = TRUE;
							//存储故障次数
							MC_RunLog2.Circuit_FaultCnt++;
							RunLogSaveIndex = 2;
						}							
					}		
				}		
				else
				{
					if( (TEComOKFlag == TRUE)||(SyncClockFreqScan>200) )
					{
						*inverterExistFlag = TRUE;
					}
					else
					{
						if( (Hardware_AD>3723)||(Hardware_AD<372) ) //新电路板电阻短路或断路
						{
							HardwareFaultCount2++;
							if( HardwareFaultCount2>= 250)                  
							{
								HardwareFaultCount2 = 0;
								p_MC_ErrorCode->ERROR_Bit.Fault_Circuit = 1;
								//记录故障日志
								MC_ErrorLogSaveInfo.NotesInfo1 = 9;       
								MC_ErrorLogSaveInfo.NotesInfo2 = (SyncClockFreqScan<<2)+TEComOKFlag;
								MC_ErrorLogSaveInfo.NotesInfo3 = Hardware_AD;
								ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
								IsErrorLogSaveInfoUpdateFlag = TRUE;
								//存储故障次数
								MC_RunLog2.Circuit_FaultCnt++;
								RunLogSaveIndex = 2;
							}							
						}
						else
						{
							HardwareFaultCount2 = 0;
						}
					}
				}				
			}
		}
	}
	else
	{

	}
}

/***********************全局函数定义***********************/
//霍尔传感器故障检测
void MC_Fault_HallSensor_Process(MC_HallSensorStatus_Struct_t HallSensorStatus, MC_ErrorCode_Struct_t* p_MC_ErrorCode)
{
	static TrueOrFalse_Flag_Struct_t IsFirstEnterFlag = TRUE;
	static uint32_t TrigTimeCnt_1 = 0, TrigTimeCnt_2 = 0;//用于检测霍尔全部短路或开路检测 延时判断
	static uint8_t HallGroupOldBak[6];//用于单个霍尔故障判断霍尔状态缓存
	static uint8_t Count = 0;
	static uint32_t TrigCnt_2 = 0;//用于单个霍尔故障次数计数
		
	if(IsFirstEnterFlag == TRUE)
	{
		TrigTimeCnt_1 = HAL_GetTick();
		memset(HallGroupOldBak, HallSensorStatus.HallGropuStatus_Old, sizeof(HallGroupOldBak));
		IsFirstEnterFlag = FALSE;
	}
		
	if(p_MC_ErrorCode->ERROR_Bit.Fault_HallSensor == 0)
	{
	  //霍尔传感器全部短路或开路检测
		if((HallSensorStatus.HallGropuStatus == 0x00) || (HallSensorStatus.HallGropuStatus == 0x07))
		{
		  if((HAL_GetTick() - TrigTimeCnt_1) > 1000)
			{
			  p_MC_ErrorCode->ERROR_Bit.Fault_HallSensor = 1;
				//记录故障日志
				MC_ErrorLogSaveInfo.NotesInfo1 = 1;
				MC_ErrorLogSaveInfo.NotesInfo2 = (uint16_t)HallSensorStatus.HallGropuStatus;
				ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
				IsErrorLogSaveInfoUpdateFlag = TRUE;
				//存储故障次数
				MC_RunLog1.Hall_FaultCnt++;
			  RunLogSaveIndex = 1;			
				
				return;
			}
		}
		else
		{
	  	TrigTimeCnt_1 = HAL_GetTick();
		}
		
		//相邻黏连检测和单个短、开路检测		
		if(HallSensorStatus.HallGropuStatus != HallSensorStatus.HallGropuStatus_Old)
		{
			HallGroupOldBak[Count++] = HallSensorStatus.HallGropuStatus;
			if(Count >= 6)
			{
			  Count = 0;
				//检测是否有霍尔异常
				if(CheckIsHasDouble(HallGroupOldBak, sizeof(HallGroupOldBak)) == TRUE)
				{
				  TrigCnt_2++;
				}
				else
				{
				  TrigCnt_2 = 0;
					TrigTimeCnt_2 = HAL_GetTick();
				}
				if( (TrigCnt_2 > 50) && (HAL_GetTick()>(TrigTimeCnt_2+500)) )
				{
					p_MC_ErrorCode->ERROR_Bit.Fault_HallSensor = 1;
					//记录故障日志
					MC_ErrorLogSaveInfo.NotesInfo1 = 2;
					MC_ErrorLogSaveInfo.NotesInfo2 = ((uint16_t)HallGroupOldBak[0] << 8) + ((uint16_t)HallGroupOldBak[1] << 4) + ((uint16_t)HallGroupOldBak[2]);	
					MC_ErrorLogSaveInfo.NotesInfo3 = ((uint16_t)HallGroupOldBak[3] << 8) + ((uint16_t)HallGroupOldBak[4] << 4) + ((uint16_t)HallGroupOldBak[5]);
			  	ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
			  	IsErrorLogSaveInfoUpdateFlag = TRUE;
					//存储故障次数
					MC_RunLog1.Hall_FaultCnt++;
			    RunLogSaveIndex = 1;			
					
					return;
				}
			}
		}
	}
}

//踏频传感器故障检测
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状态
	static uint32_t Hall_1_Fault_TrigTimeCnt = 0;
	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_1_2_EQA_Flag = 1;
	static uint32_t Hall_1_2_EQA_TrigTimeCnt = 0;
	static uint8_t Hall_1_State;
	static uint8_t Hall_2_State;
		
	Hall_1_State = HAL_GPIO_ReadPin(CADENCE_1_GPIO_Port, CADENCE_1_Pin);
	Hall_2_State = HAL_GPIO_ReadPin(CADENCE_2_GPIO_Port, CADENCE_2_Pin);
	
	//更新霍尔1信号变化状态，相同为0，不同为1
	Hall_1_Trg = Hall_1_State ^ Hall_1_Cont;
	Hall_1_Cont = Hall_1_State;
	//更新霍尔2信号变化状态，相同为0，不同为1
	Hall_2_Trg = Hall_2_State ^ Hall_2_Cont;
	Hall_2_Cont = Hall_2_State;
	//更新霍尔1和霍尔2相同标志，相同为0，不同为1
	Hall_1_2_EQA_Flag = Hall_1_State ^ Hall_2_State;
	
	if(HAL_GetTick() < 1000)
	{
	  Hall_1_Fault_TrigTimeCnt = HAL_GetTick();
		Hall_2_Fault_TrigTimeCnt = HAL_GetTick();
		Hall_1_2_EQA_TrigTimeCnt = HAL_GetTick();
		return;
	}
	
	if(p_MC_ErrorCode->ERROR_Bit.Fault_CadenceSensor == 0)
	{		
		//两个霍尔传感器分别检测是否存在开路或短路 
		if((Torque > 1200) && (BikeSpeed > 70))
		{
		  //判断霍尔1
			if(Hall_1_Trg == 0)
			{
			  if((HAL_GetTick() - Hall_1_Fault_TrigTimeCnt) > 10000)
				{
				  p_MC_ErrorCode->ERROR_Bit.Fault_CadenceSensor = 1;
					//记录故障日志
					MC_ErrorLogSaveInfo.NotesInfo1 = 1;
			  	ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
			  	IsErrorLogSaveInfoUpdateFlag = TRUE;
					//存储故障次数
          MC_RunLog2.CadenceSensor_FaultCnt++;
					RunLogSaveIndex = 2;
					
					return;
				}
			}
			else
			{
			  Hall_1_Fault_TrigTimeCnt = HAL_GetTick();
			}
			//判断霍尔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();
			}		
      //判断霍尔1和霍尔2黏连
      if(Hall_1_2_EQA_Flag == 0) 
			{
			  if((HAL_GetTick() - Hall_1_2_EQA_TrigTimeCnt) > 10000)
				{
				  p_MC_ErrorCode->ERROR_Bit.Fault_CadenceSensor = 1;
					//记录故障日志
					MC_ErrorLogSaveInfo.NotesInfo1 = 3;
				  ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
				  IsErrorLogSaveInfoUpdateFlag = TRUE;
					//存储故障次数
          MC_RunLog2.CadenceSensor_FaultCnt++;
					RunLogSaveIndex = 2;
					
					return;
				}
			}		
      else
			{
			  Hall_1_2_EQA_TrigTimeCnt = HAL_GetTick();
			}				
		}
		else
		{
		  Hall_1_Fault_TrigTimeCnt = HAL_GetTick();
		  Hall_2_Fault_TrigTimeCnt = HAL_GetTick();
			Hall_1_2_EQA_TrigTimeCnt = HAL_GetTick();
		}
	}
}

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)
{	
	//速度传感器故障检测
	if((MC_WorkMode == MC_WorkMode_Run) && (MC_ConfigParam1.SpeedSignal == MC_SPEED_WHEEL_TRIG))
	{
		MC_Fault_SpeedSensor_Process(MC_SpeedSensorData.IsStopFlag, MC_CadenceResult, MC_RunInfo.MotorSpeed, MC_CalParam.AssistRunMode, &MC_ErrorCode);
	}

	//力矩传感器故障检测
	MC_Fault_TorqueSensor_Process(&ADC1_Result[ADC1_RANK_TORQUE_SENSOR_1], MC_ControlCode.GearSt, MC_CadenceResult, MC_CalParam.AssistRunMode, &TorsueSensorFaultStatus, &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_Coil, &MC_ErrorCode);

	//指拨故障检测
	MC_Fault_GasSensor_Process(ADC1_Result[ADC1_RANK_GAS], &MC_ErrorCode);

	//MOS故障检测
	MC_Fault_MOS_Process(ADC_3ShuntCurrent_RMSValue, &MC_ErrorCode);

  //TE故障检测
	#if 0
	MC_Fault_TE_Process(&MC_TE_SensorStatus, IsComOK_TE.IsOK_Flag, &MC_ErrorCode);
	#endif
	
	//电路故障检测
	MC_Fault_Circuit_Process(&MC_ErrorCode);
	
	//单向器打滑故障检测
	MC_Fault_Machine_Process(MC_RunInfo.MotorSpeed, MC_CadenceResult.Cadence_Data, ADC_SensorData, SpeedRatio, &MC_ErrorCode);

	//硬件识别故障
	MC_Fault_Hardware_Identify(IsComOK_TE.IsOK_Flag, MC_TE_SyncClockFreqScan, ADC1_Result_Filt[ADC1_RANK_HARDWARE_VER], &MC_HallSensorData.InverterExistFlag, &MC_ErrorCode);
}