#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"

/*********************************局部函数定义*****************************/
//速度传感器故障检测
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;
					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;
					return;
				}
			}
			else
			{
				TrigTimeCnt_2 = HAL_GetTick();
			}
		}
	}
}

//力矩传感器故障检测
void MC_Fault_TorqueSensor_Process(uint16_t ADC_Data, MC_GearSt_Struct_t GearSt, MC_CadenceResult_Struct_t CadenceData, MC_ErrorCode_Struct_t* p_MC_ErrorCode)
{
  static uint32_t TrigTimeCnt_1 = 0;
	static uint32_t TrigTimeCnt_2 = 0;
	static uint16_t TorqueArray[10] = {0};
	static uint32_t DiffSqrtResult = 0;
	uint16_t i;
	uint16_t DelayTime;
	
	if(HAL_GetTick() < 2000)
	{
	  TrigTimeCnt_1 = HAL_GetTick();
		TrigTimeCnt_2 = HAL_GetTick();
	}
	
	#if INSERT_FAULT_TEST_FLAG  //插入故障测试
	if(InsertFault_Flag == INSERT_FAULT_TORQUESENSOR_0)
	{
	  ADC_Data = 0;
	}
	else if(InsertFault_Flag == INSERT_FAULT_TORQUESENSOR_4095)
	{
	  ADC_Data = 4095;
	}
	else if(InsertFault_Flag == INSERT_FAULT_TORQUESENSOR_1500)
	{
	  ADC_Data = 1500;
	}
	#endif
	
	for(i=0; i<(sizeof(TorqueArray) / 2 - 1); i++)
	{
	  TorqueArray[i] = TorqueArray[i + 1];
	}
	TorqueArray[sizeof(TorqueArray) / 2 - 1] = ADC_Data;
	
	if(p_MC_ErrorCode->ERROR_Bit.Fault_TorqueSensor == 0)
	{
	  DiffSqrtResult = GetStandardDeviation(TorqueArray, sizeof(TorqueArray) / 2);
		//传感器感应失效检测，进入助力模式、踏频正转大于10rpm、均方差值较小
		if(((GearSt != 0x22) && ((GearSt & 0x0F) != 0)) && (CadenceData.Cadence_Data > 10) && (CadenceData.Cadence_Dir == MC_Cadence_Forward) && (DiffSqrtResult < 5))
		{
		  DelayTime = 15000 / CadenceData.Cadence_Data;  //根据踏频计算踩踏1/4圈的时间，要考虑空踩情况
			DelayTime = (DelayTime < 250) ? 250 : DelayTime;
			if((HAL_GetTick() - TrigTimeCnt_1) > DelayTime)
			{
			  p_MC_ErrorCode->ERROR_Bit.Fault_TorqueSensor = 1;
				return;
			}
		}
		else
		{
		  TrigTimeCnt_1 = HAL_GetTick();
		}
		//传感器短路或开路检测
		if((ADC_Data < 50) || (ADC_Data > 4050))
		{
		  if((HAL_GetTick() - TrigTimeCnt_2) > 200)
		  {
		    p_MC_ErrorCode->ERROR_Bit.Fault_TorqueSensor = 1;
				return;
	  	}
		}
		else
		{
		  TrigTimeCnt_2 = HAL_GetTick();
		}
	}
}

//缺相检测
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 > 1000) && (MotorSpeed > 100))
		{
		  //A相电流
			if(abs(Phase_Current.uw_phase_a) < 100)
			{
			  if((HAL_GetTick() - TrigTimeCnt_PhaseA) > 250)
				{
		  		p_MC_ErrorCode->ERROR_Bit.Fault_PhaseLine = 1;
					return;
				}
			}
			else
			{
			  TrigTimeCnt_PhaseA = HAL_GetTick();
			}
			//B相电流
			if(abs(Phase_Current.uw_phase_b) < 100)
			{
			  if((HAL_GetTick() - TrigTimeCnt_PhaseB) > 250)
				{
		  		p_MC_ErrorCode->ERROR_Bit.Fault_PhaseLine = 1;
					return;
				}
			}
			else
			{
			  TrigTimeCnt_PhaseB = HAL_GetTick();
			}
			//C相电流
			if(abs(Phase_Current.uw_phase_c) < 100)
			{
			  if((HAL_GetTick() - TrigTimeCnt_PhaseC) > 250)
				{
		  		p_MC_ErrorCode->ERROR_Bit.Fault_PhaseLine = 1;
					return;
				}
			}
			else
			{
			  TrigTimeCnt_PhaseC = HAL_GetTick();
			}
		}
		else if(Foc_Flag == RESET)
		{
		  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_Roil_Result, MC_ErrorCode_Struct_t* p_MC_ErrorCode)
{
  static uint32_t TrigTimeCnt_PCB = 0;         //PCB NTC采集异常计时
	static uint32_t TrigTimeCnt_Roil = 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_Roil_Old = 0;
		
	//为初始化预留1s
	if((HAL_GetTick() < 1000) || (MC_RunInfo.T_MCU > 90))//50度以上，不检测NTC故障
	{
	  TrigTimeCnt_PCB = HAL_GetTick();
		TrigTimeCnt_PCB = HAL_GetTick();
		T_PCB_Old = T_PCB_Result;
		T_Roil_Old = T_Roil_Result;
		
		if(HAL_GetTick() < 1000)
		{
		  NTC_Check_PeriodTimeCnt = HAL_GetTick();
			return;
		}		
	}
	
	if(p_MC_ErrorCode->ERROR_Bit.Fault_NtcSensor == 0)
	{
	  //PCB上NTC短路或开路检测，判断AD值是否为异常值
	  if((T_PCB_Result < 20) || (T_PCB_Result > 140))//20:AD为3812，140:AD为227
		{
			if((HAL_GetTick() - TrigTimeCnt_PCB) > 200)
			{
				p_MC_ErrorCode->ERROR_Bit.Fault_NtcSensor = 1;
				return;
			}
		}
		else
		{
	  	TrigTimeCnt_PCB = HAL_GetTick();
		}
		
	  //NTC短路或开路检测，判断AD值是否为异常值
		if(((T_Roil_Result < 20) || (T_Roil_Result > 140)) ||	
			 ((T_PCB_Result < 20) || (T_PCB_Result > 140))
		  )
		{
			if((HAL_GetTick() - TrigTimeCnt_Roil) > 200)
			{
				p_MC_ErrorCode->ERROR_Bit.Fault_NtcSensor = 1;
				return;
			}
		}
		else
		{
		  TrigTimeCnt_Roil = HAL_GetTick();
		}
		
		//NTC为固定值的检测，检测3min内母线电流平均值 > 5A 时的前后温差
		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 * 2048 = 204.8s内母线电流平均值
			if(NTC_Check_Count >= 2048)
			{
			  NTC_Check_Count = 0;
				BusCurrentAvg = BusCurrentSum >> 11;
				BusCurrentSum = 0;
				//平均电流超过5A，判断是否有温升
				if(BusCurrentAvg > 39) // 39  * 1.28 = 50
				{
				  if((abs(T_PCB_Result - T_PCB_Old) < 2) ||  //PCB 温升低于5度
						 (abs(T_Roil_Result - T_Roil_Old) < 2))  //绕组温升低于3度
					{
					  p_MC_ErrorCode->ERROR_Bit.Fault_NtcSensor = 1;
				    return;
					}
				}
				T_PCB_Old = T_PCB_Result;
				T_Roil_Old = T_Roil_Result;
			}
		}		
	}
}

//踏频传感器故障检测
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;
	uint8_t Hall_1_State;
	uint8_t Hall_2_State;
	
  #if INSERT_FAULT_TEST_FLAG  //模拟插入故障测试
	if(InsertFault_Flag == INSERT_FAULT_NC)
	{
  	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);
	}
  else if(InsertFault_Flag == INSERT_FAULT_CADENCE_HALL1_OC)
	{
	  Hall_1_State = 0x01;
		Hall_2_State = HAL_GPIO_ReadPin(CADENCE_2_GPIO_Port, CADENCE_2_Pin);
	}
	else if(InsertFault_Flag == INSERT_FAULT_CADENCE_HALL1_SC)
	{
	  Hall_1_State = 0x00;
		Hall_2_State = HAL_GPIO_ReadPin(CADENCE_2_GPIO_Port, CADENCE_2_Pin);
	}
	#else
	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);
  #endif
	//更新霍尔1信号变化状态
	Hall_1_Trg = Hall_1_State ^ Hall_1_Cont;
	Hall_1_Cont = Hall_1_State;
	//更新霍尔2信号变化状态
	Hall_2_Trg = Hall_2_State ^ Hall_2_Cont;
	Hall_2_Cont = Hall_2_State;
	//更新霍尔1和霍尔2相同标志
	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 > 1000) && (BikeSpeed > 100))
		{
		  //判断霍尔1
			if(Hall_1_Trg == 0)
			{
			  if((HAL_GetTick() - Hall_1_Fault_TrigTimeCnt) > 300)
				{
				  p_MC_ErrorCode->ERROR_Bit.Fault_CadenceSensor = 1;
					return;
				}
			}
			else
			{
			  Hall_1_Fault_TrigTimeCnt = HAL_GetTick();
			}
			//判断霍尔2
			if(Hall_2_Trg == 0)
			{
			  if((HAL_GetTick() - Hall_2_Fault_TrigTimeCnt) > 300)
				{
				  p_MC_ErrorCode->ERROR_Bit.Fault_CadenceSensor = 1;
					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) > 300)
				{
				  p_MC_ErrorCode->ERROR_Bit.Fault_CadenceSensor = 1;
					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_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) > 200)
			{
			  p_MC_ErrorCode->ERROR_Bit.Fault_MOS = 1;
				return;
			}
		}
		else
		{
		  TrigTimeCnt_A = HAL_GetTick();
		}
		//B相MOS短路
		if(abs(ShuntCurrent.uw_phase_b) > 20000)
		{
		  if((HAL_GetTick() - TrigTimeCnt_B) > 200)
			{
			  p_MC_ErrorCode->ERROR_Bit.Fault_MOS = 1;
				return;
			}
		}
		else
		{
		  TrigTimeCnt_B = HAL_GetTick();
		}
		//C相MOS短路
		if(abs(ShuntCurrent.uw_phase_c) > 20000)
		{
		  if((HAL_GetTick() - TrigTimeCnt_C) > 200)
			{
			  p_MC_ErrorCode->ERROR_Bit.Fault_MOS = 1;
				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 uint32_t TrigTimeCnt_Com = 0;
  static uint32_t TrigTimeCnt_Sensor = 0;
	static uint32_t DelayTimeCnt_Sensor = 0;
	static FlagStatus SensorCheckFault_Falg = RESET;
	static FlagStatus TE_ComFault_Flag = RESET;
	
	//传感器检测异常判断
	if(SensorCheckFault_Falg == RESET)
	{
	  if((p_MC_TE_SensorStatus->TE_ErrorCode.Code != 0) || (p_MC_TE_SensorStatus->MCU_Voltage > 3800))  //存在传感器检测异常，或主MCU工作电压大于4.2V
		{
			if((HAL_GetTick() - TrigTimeCnt_Sensor) > 1000)
			{
				SensorCheckFault_Falg = SET;
			}
		}
		else
		{
		  TrigTimeCnt_Sensor = HAL_GetTick();
		}
	}
	//传感器检测异常恢复判断
	else
	{
	  if((p_MC_TE_SensorStatus->TE_ErrorCode.Code == 0) && (p_MC_TE_SensorStatus->MCU_Voltage < 3600))
		{
		  if((HAL_GetTick() - DelayTimeCnt_Sensor) > 1000)
			{
			  SensorCheckFault_Falg = RESET;
			}
		}
		else
		{
		  DelayTimeCnt_Sensor = HAL_GetTick();
		}
	}
	
	//TE通信异常判断
	if(TE_ComFault_Flag == RESET)
	{
	  if(ComOK_Flag == FALSE)
		{
			if((HAL_GetTick() - TrigTimeCnt_Com) > 3000)
			{
				TE_ComFault_Flag = SET;
			}
		}
		else
		{
			TrigTimeCnt_Com = HAL_GetTick();
		}
	}
	//TE通信异常恢复判断
	else
	{
	  if(ComOK_Flag == TRUE)
		{
			TE_ComFault_Flag = RESET;
		}
	}
	
	//故障码输出
	if((SensorCheckFault_Falg == RESET) && (TE_ComFault_Flag == RESET))
	{
	  p_MC_ErrorCode->ERROR_Bit.Fault_MCU = 0;
	}
	else
	{
	  if(SensorCheckFault_Falg == SET)
		{
      p_MC_ErrorCode->ERROR_Bit.Fault_Circuit = 1;  //认为电路故障
		}
		if(TE_ComFault_Flag == SET)                     //认为MCU故障
		{
	  	p_MC_ErrorCode->ERROR_Bit.Fault_MCU = 1;
		}
	}
}

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; //驱动电源判断计时
	
	//为初始化预留3s
	if(HAL_GetTick() < 5000)
	{
	  PeriodTimeCnt = HAL_GetTick();
		C31_SC_TrigTimeCnt = HAL_GetTick();
		PowerDriver_TrigTimeCnt = HAL_GetTick();
		return;
	}
	
	//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;
		}
	}
	else
	{
  	C31_SC_TrigTimeCnt = HAL_GetTick();
	}
	
	//MOS驱动电源异常检测
	if((FOC_Status == FOC_Status_RUN) && 
		 (MC_CalParam.AssistRunMode != MC_AssistRunMode_INVALID) &&
	   (MC_CalParam.Foc_Flag == SET) &&
	   ((MC_CalParam.Ref_Speed > 100) || (MC_CalParam.Ref_Torque > 100))
	  )
  {
	  if((MC_RunInfo.MotorSpeed < 5) && (MC_RunInfo.BusCurrent < 2000))
		{
		  if((HAL_GetTick() - PowerDriver_TrigTimeCnt) > 3000)
			{
			  p_MC_ErrorCode->ERROR_Bit.Fault_Circuit = 1;
			}
		}
		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;
		#if 1 //正常运行
		BusCurrent_Flt += ADC1_Result_Filt[ADC1_RANK_CURRENT];
		#elif 1 //模拟母线电流采样为固定值
		BusCurrent_Flt += 2048;
		#endif
		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) < 8000) || ((PhasesCurrentA_Flt >> 5) > 60000)) ||     //A相电流采样异常
			   (((PhasesCurrentB_Flt >> 5) < 8000) || ((PhasesCurrentB_Flt >> 5) > 60000)) ||     //B相电流采样异常
			   (((PhasesCurrentC_Flt >> 5) < 8000) || ((PhasesCurrentC_Flt >> 5) > 60000))        //C相电流采样异常
			  )
			{
			  p_MC_ErrorCode->ERROR_Bit.Fault_Circuit = 1;
			}
			
			if((IqFdbFlt >> 10) > 200)
			{
				if(((BusCurrent_Flt >> 5) - uw_current_offset) < 50) //50对应的母线电流约1.2A
				{
				  CurrentFaultCount++;
			  	if(CurrentFaultCount > 10)
				  {
				    p_MC_ErrorCode->ERROR_Bit.Fault_Circuit = 1;
						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) > 3000) // 由运动转为静止3s后进行判断
			{
				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;
					}
				}
			}
		}
		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) > 200)
			{
			  p_MC_ErrorCode->ERROR_Bit.Fault_HallSensor = 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 > 20)
				{
					p_MC_ErrorCode->ERROR_Bit.Fault_HallSensor = 1;
					return;
				}
			}
		}
	}
}

//故障检测
void MC_Fault_Check_Process(void)
{
	//速度传感器故障检测
	if(MC_WorkMode == MC_WorkMode_Run)
	{
		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], 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_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_GasSensor_Process(ADC1_Result[ADC1_RANK_GAS], &MC_ErrorCode);

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

  //TE故障检测
	MC_Fault_TE_Process(&MC_TE_SensorStatus, IsComOK_TE, &MC_ErrorCode);
	
	//电路故障检测
	MC_Fault_Circuit_Process(&MC_ErrorCode);
}