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)
		{
		  if((MotorSpeed > 50) && (IsStopFlag == TRUE))
			{
			  DelayTime = 1650000 / MotorSpeed;//考虑前后齿比为0.8的情况下，轮子转一圈的时间为：60 / (电机转速 / (4.55 * 2.4) * 0.8) s, 延长2圈时间
				DelayTime = DelayTime < 2000 ? 2000 : 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 = 150000 / CadenceSensor.Cadence_Data;//考虑前后齿比为0.8的情况下，轮子转一圈的时间为：60 / (踏频 * 0.8) s, 延长2圈时间
				DelayTime = DelayTime < 2000 ? 2000 : 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 < 12)
	{
		DelayTime = 15000 / Cadence;  //根据踏频计算踩踏1/4圈的时间，要考虑空踩情况
		DelayTime = (DelayTime < 250) ? 250 : DelayTime;
		if((HAL_GetTick() - p_SensorCheck->TrigTimeCnt_1) > (DelayTime * 2))
		{
			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) > 250)
		{
			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))
	{	  
		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);
			
		}	
	}

	//综合判断
	if(p_MC_ErrorCode->ERROR_Bit.Fault_TorqueSensor == 0)
	{
	  if((SensorFaultStatus->FaultBit.Sensor1 + SensorFaultStatus->FaultBit.Sensor2 + SensorFaultStatus->FaultBit.Sensor3) > 1)//超过2个传感器异常
		{
		  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) > 3000)
				{
		  		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) > 3000)
				{
		  		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) > 3000)
				{
		  		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;
	uint8_t BusCurrentAvg = 0;
	static uint8_t T_PCB_Old = 0;
	static uint8_t T_Coil_Old = 0;
		
	//初始化5s，且50度以上，不检测NTC故障
	if((HAL_GetTick() < 5000) || (MC_RunInfo.T_MCU > 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 > 180))           //5(-35度):AD为4000，180(140度):AD为80
		{
			if((HAL_GetTick() - TrigTimeCnt_PCB) > 500)
			{
				p_MC_ErrorCode->ERROR_Bit.Fault_NtcSensor = 1;
				//记录故障日志
				MC_ErrorLogSaveInfo.NotesInfo1 = 1;
				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 > 180))    //5(-35度):AD为4000，180(140度):AD为80
		{
			if((HAL_GetTick() - TrigTimeCnt_Coil) > 500)
			{
				p_MC_ErrorCode->ERROR_Bit.Fault_NtcSensor = 1;
				//记录故障日志
				MC_ErrorLogSaveInfo.NotesInfo1 = 2;
				ErrorLogSave_Update(&MC_ErrorLogSaveInfo);
				IsErrorLogSaveInfoUpdateFlag = TRUE;
				//存储故障次数
				MC_RunLog1.NTC_FaultCnt++;
			  RunLogSaveIndex = 1;
				
				return;
			}
		}
		else
		{
		  TrigTimeCnt_Coil = HAL_GetTick();
		}
		
		//NTC为固定值的检测，检测3min内母线电流平均值 > 10A 时的前后温差
		if((HAL_GetTick() - NTC_Check_PeriodTimeCnt) >= 100)
		{
		  NTC_Check_PeriodTimeCnt = HAL_GetTick();
			BusCurrentSum += MC_RunInfo.BusCurrent >> 7;//按照mA / 128 判断，约0.1A
			NTC_Check_Count++;
			//采集100 * 8192 = 819.2s内母线电流平均值
			if(NTC_Check_Count >= 8192)
			{
			  NTC_Check_Count = 0;
				BusCurrentAvg = BusCurrentSum >> 13;//8192个值取均值
				BusCurrentSum = 0;
				//平均电流超过10A，判断是否有温升
				if(BusCurrentAvg > 79) // 79  * 1.28 = 101
				{
				  if((abs(T_PCB_Result - T_PCB_Old) < 2) ||  //PCB 温升低于2度
						 (abs(T_Coil_Result - T_Coil_Old) < 2))  //绕组温升低于2度
					{
					  p_MC_ErrorCode->ERROR_Bit.Fault_NtcSensor = 1;
						//记录故障日志
				  	MC_ErrorLogSaveInfo.NotesInfo1 = 3;
						MC_ErrorLogSaveInfo.NotesInfo2 = BusCurrentAvg;
						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) < 50) //50对应的母线电流约1.2A, 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_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;//用于检测霍尔全部短路或开路检测 延时判断
	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) > 250)
			{
			  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;
				}
				if(TrigCnt_2 > 50)
				{
					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_Process(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) > 5000)
				{
				  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) > 5000)
				{
				  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) > 5000)
				{
				  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_Check_Process(void)
{	
	//速度传感器故障检测
	if((MC_WorkMode == MC_WorkMode_Run) && (MC_ConfigParam1.No_SpeedSensor_Flag != MC_SUPPORT_ENABLE))
	{
		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
	if(TE_CheckFlag == SET)//针对样机的TE软件版本，不检测故障
	{
  	MC_Fault_TE_Process(&MC_TE_SensorStatus, IsComOK_TE.IsOK_Flag, &MC_ErrorCode);
	}	
	#elif 1
	MC_Fault_TE_Process(&MC_TE_SensorStatus, IsComOK_TE.IsOK_Flag, &MC_ErrorCode);
	#endif
	
	//电路故障检测
	MC_Fault_Circuit_Process(&MC_ErrorCode);
}