#include "fault_check.h"
#include "math_tools.h"
#include "motor_control.h"
#include "hall_sensor.h"
#include "usart.h"
#include "can.h"
#include "MC_FOC_Driver.h"
#include "MC_Globals.h"

/*********************************局部函数定义*****************************/
//速度传感器故障检测
void MC_Fault_SpeedSensor_Process(uint16_t BikeSpeed, 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) && (BikeSpeed == 0))
			{
			  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) && (BikeSpeed == 0))
			{
				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, uint16_t Cadence, MC_ErrorCode_Struct_t* p_MC_ErrorCode)
{
  static uint32_t TrigTimeCnt_1 = 0;
	static uint32_t TrigTimeCnt_2 = 0;
	static uint16_t Array[10] = {0};
	static TrueOrFalse_Flag_Struct_t IsFirstEnterFlag = TRUE;
	uint16_t i;
	
	if(IsFirstEnterFlag == TRUE)
	{
	  IsFirstEnterFlag = FALSE;
		TrigTimeCnt_1 = 0;
		TrigTimeCnt_2 = 0;
	}
	
	for(i=0; i<(sizeof(Array) / 2 - 1); i++)
	{
	  Array[i] = Array[i + 1];
	}
	Array[sizeof(Array) / 2 - 1] = ADC_Data;
	
	if(p_MC_ErrorCode->ERROR_Bit.Fault_TorqueSensor == 0)
	{
	  //传感器感应失效检测
		if(((GearSt & 0x0F) != 0) && (Cadence > 5) && (GetStandardDeviation(Array, sizeof(Array) / 2) < 2))
		{
		  if((HAL_GetTick() - TrigTimeCnt_1) > 5000)
			{
			  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, 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))
		{
		  //A相电流
			if(abs(Phase_Current.uw_phase_a) < 25)
			{
			  if((HAL_GetTick() - TrigTimeCnt_PhaseA) > 200)
				{
		  		p_MC_ErrorCode->ERROR_Bit.Fault_PhaseLine = 1;
					return;
				}
			}
			else
			{
			  TrigTimeCnt_PhaseA = HAL_GetTick();
			}
			//B相电流
			if(abs(Phase_Current.uw_phase_b) < 25)
			{
			  if((HAL_GetTick() - TrigTimeCnt_PhaseB) > 200)
				{
		  		p_MC_ErrorCode->ERROR_Bit.Fault_PhaseLine = 1;
					return;
				}
			}
			else
			{
			  TrigTimeCnt_PhaseB = HAL_GetTick();
			}
			//C相电流
			if(abs(Phase_Current.uw_phase_c) < 25)
			{
			  if((HAL_GetTick() - TrigTimeCnt_PhaseC) > 200)
				{
		  		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;
	static uint32_t TrigTimeCnt_Roil = 0;
	static TrueOrFalse_Flag_Struct_t IsFirstEnterFlag = TRUE;
	
	if(IsFirstEnterFlag == TRUE)
	{
	  IsFirstEnterFlag = FALSE;
		TrigTimeCnt_PCB = HAL_GetTick();
		TrigTimeCnt_PCB = HAL_GetTick();
	}
	
	//为初始化预留1s
	if((HAL_GetTick() < 1000))
	{
	  return;
	}
	
	//60度以上，不检测NTC故障
	if(MC_RunInfo.T_MCU > 100)
	{
	  return;
	}
	
	if(p_MC_ErrorCode->ERROR_Bit.Fault_NtcSensor == 0)
	{
	  //PCB上NTC短路或开路检测
	  if((T_PCB_Result < 20) || (T_PCB_Result > 140))
		{
			if((HAL_GetTick() - TrigTimeCnt_PCB) > 200)
			{
				p_MC_ErrorCode->ERROR_Bit.Fault_NtcSensor = 1;
				return;
			}
		}
		else
		{
	  	TrigTimeCnt_PCB = HAL_GetTick();
		}
	  //绕组上NTC短路或开路检测
		if((T_Roil_Result < 20) || (T_Roil_Result > 140))
		{
			if((HAL_GetTick() - TrigTimeCnt_Roil) > 200)
			{
				p_MC_ErrorCode->ERROR_Bit.Fault_NtcSensor = 1;
				return;
			}
		}
		else
		{
		  TrigTimeCnt_Roil = HAL_GetTick();
		}
	}
}

//踏频传感器故障检测
void MC_Fault_CadenceSensor_Process(uint16_t Torque, uint16_t BikeSpeed, MC_ErrorCode_Struct_t* p_MC_ErrorCode)
{
  static MC_CadenceSensorStatus_Struct_t CadenceSensorStatus;
	static TrueOrFalse_Flag_Struct_t IsFirstEnterFlag = TRUE;
	static uint32_t TrigTimeCnt_1 = 0;
	static uint32_t TrigTimeCnt_2 = 0;
	static TrueOrFalse_Flag_Struct_t TrigFlag = FALSE;
		
	CadenceSensorStatus.HallGropuStatus = Cadence_ReadHallState();
	if(IsFirstEnterFlag == TRUE)
	{
	  CadenceSensorStatus.HallGropuStatus_Old = CadenceSensorStatus.HallGropuStatus;
		TrigTimeCnt_1 = HAL_GetTick();
		TrigTimeCnt_2 = HAL_GetTick();
		IsFirstEnterFlag = FALSE;
	}
	
	if(p_MC_ErrorCode->ERROR_Bit.Fault_CadenceSensor == 0)
	{
	  //两个霍尔传感器同时检测，包含两个同时短路、开路及黏连
		if((Torque > 1000) && (BikeSpeed > 100))
		{
		  if((CadenceSensorStatus.HallGropuStatus == 0x00) || (CadenceSensorStatus.HallGropuStatus == 0x03))
			{
			  if((HAL_GetTick() - TrigTimeCnt_1) > 200)
				{
				  p_MC_ErrorCode->ERROR_Bit.Fault_CadenceSensor = 1;
					return;
				}
			}
			else
			{
	  		TrigTimeCnt_1 = HAL_GetTick();
			}
		}
		else
		{
		  TrigTimeCnt_1 = HAL_GetTick();
		}
		if(CadenceSensorStatus.HallGropuStatus != CadenceSensorStatus.HallGropuStatus_Old)
		{
			//单个霍尔传感器检测
			if((CadenceSensorStatus.HallGropuStatus != ForwardDir_EncoderData[CadenceSensorStatus.HallGropuStatus_Old]) && //不满足正转编码表
				 (CadenceSensorStatus.HallGropuStatus != BackwardDir_EncoderData[CadenceSensorStatus.HallGropuStatus_Old]))  //不满足反转编码表
			{
				if(TrigFlag == FALSE)
				{
					TrigTimeCnt_2 = HAL_GetTick();
					TrigFlag = TRUE;
				}
				if((HAL_GetTick() - TrigTimeCnt_2) > 200)
				{
					p_MC_ErrorCode->ERROR_Bit.Fault_CadenceSensor = 1;
					return;
				}
			}
			else
			{
				TrigFlag = FALSE;
			}		
		}
	}
	
	CadenceSensorStatus.HallGropuStatus_Old = CadenceSensorStatus.HallGropuStatus;
}

//指拨故障检测
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;
	static uint16_t BusCurrent_AD[10];
	static uint16_t PhaseA_AD[10];
	static uint16_t PhaseB_AD[10];
	static uint16_t PhaseC_AD[10];
	static uint8_t i = 0;
	uint16_t AvgResult_BusCurrent, AvgResult_PhaseA, AvgResult_PhaseB, AvgResult_PhaseC;
	uint32_t DiffSqrtResult_BusCurrent, DiffSqrtResult_PhaseA, DiffSqrtResult_PhaseB, DiffSqrtResult_PhaseC;
	static uint32_t PowerDriver_TrigTimeCnt = 0;
		
	//为初始化预留1s
	if(HAL_GetTick() < 1000)
	{
	  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();
	}
	
	//以下指令执行周期100ms
	if((HAL_GetTick() - PeriodTimeCnt) < 100)
	{
	  return;
	}
	PeriodTimeCnt = HAL_GetTick();
	
	//更新母线电流、相线电流缓存数据，更新周期100ms
	BusCurrent_AD[i] = ADC1_Result_Filt[ADC1_RANK_CURRENT];
	PhaseA_AD[i] = ADC2_Result[ADC2_RANK_CURRENT_A];
	PhaseB_AD[i] = ADC2_Result[ADC2_RANK_CURRENT_B];
	PhaseC_AD[i] = ADC2_Result[ADC2_RANK_CURRENT_C];
	i++;
  if(i < 10)
	{
	  return;
	}
	i = 0;
	
	//母线电流采集异常检测
	AvgResult_BusCurrent = GetAverageData(BusCurrent_AD, sizeof(BusCurrent_AD) >> 1);
	DiffSqrtResult_BusCurrent = GetStandardDeviation(BusCurrent_AD, sizeof(BusCurrent_AD) >> 1);
	if((AvgResult_BusCurrent < 500) ||   
	   (((MC_RunInfo.GearSt == 0) && (MC_RunInfo.MotorSpeed == 0)) && (DiffSqrtResult_BusCurrent > 500)) || //随机跳动，需在静止状态检测
	   (((IqFdbFlt >> 10) > 100) && (abs(AvgResult_BusCurrent - uw_current_offset) < 10))  //相线电流大于约3A时，母线电流无变化
	  )
	{
	  p_MC_ErrorCode->ERROR_Bit.Fault_Circuit = 1;
	}	
	
	//相线电流采集异常检测
	AvgResult_PhaseA = GetAverageData(PhaseA_AD, sizeof(PhaseA_AD) >> 1);
	DiffSqrtResult_PhaseA = GetStandardDeviation(PhaseA_AD, sizeof(PhaseA_AD) >> 1);
	AvgResult_PhaseB = GetAverageData(PhaseB_AD, sizeof(PhaseB_AD) >> 1);
	DiffSqrtResult_PhaseB = GetStandardDeviation(PhaseB_AD, sizeof(PhaseB_AD) >> 1);
	AvgResult_PhaseC = GetAverageData(PhaseC_AD, sizeof(PhaseC_AD) >> 1);
	DiffSqrtResult_PhaseC = GetStandardDeviation(PhaseC_AD, sizeof(PhaseC_AD) >> 1);
	if(((AvgResult_PhaseA < 6000) || (AvgResult_PhaseB < 6000) || (AvgResult_PhaseC < 6000)) ||
		 (((MC_RunInfo.GearSt == 0) && (MC_RunInfo.MotorSpeed == 0)) && ((DiffSqrtResult_PhaseA > 10000) || (DiffSqrtResult_PhaseB > 10000) || (DiffSqrtResult_PhaseC > 10000)))
		)
	{
	  p_MC_ErrorCode->ERROR_Bit.Fault_Circuit = 1;
	}	
}

//CAN设备通信状态检测处理
void MC_Fault_CanRx_Process(MC_ErrorCode_Struct_t* p_MC_ErrorCode)
{
  //PBU通信状态检测
	if(IsComOK_PBU.IsOK_Flag == TRUE)
	{
	  p_MC_ErrorCode->ERROR_Bit.Fault_PBU_Check = 0;
		if((HAL_GetTick() - IsComOK_PBU.OK_TrigTime) > 1000)
	  {  
	    IsComOK_PBU.IsOK_Flag = FALSE;
			p_MC_ErrorCode->ERROR_Bit.Fault_PBU_Check = 1;
	  }
	}	
}

/***********************全局函数定义***********************/
//霍尔传感器故障检测
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 uint32_t TrigTimeCnt_2 = 0;
	static TrueOrFalse_Flag_Struct_t TrigFlag = FALSE;
		
	if(IsFirstEnterFlag == TRUE)
	{
		TrigTimeCnt_1 = HAL_GetTick();
		TrigTimeCnt_2 = HAL_GetTick();
		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)
		{
			if((HallSensorStatus.HallGropuStatus != HallSensorGroup_Encoder_Forward[HallSensorStatus.HallGropuStatus_Old]) &&  //不满足正转编码
				 (HallSensorStatus.HallGropuStatus != HallSensorGroup_Encoder_Backward[HallSensorStatus.HallGropuStatus_Old]))   //不满足反转编码
			{
				if(TrigFlag == FALSE)
				{
					TrigTimeCnt_2 = HAL_GetTick();
					TrigFlag = TRUE;
				}
				if((HAL_GetTick() - TrigTimeCnt_2) > 200)
				{
					p_MC_ErrorCode->ERROR_Bit.Fault_HallSensor = 1;
					return;
				}
			}
			else
			{
				TrigFlag = FALSE;
			}
		}
		else
		{
		  TrigFlag = FALSE;
		}
	}
}

//故障检测
void MC_Fault_Check_Process(void)
{
	//速度传感器故障检测
	if(MC_WorkMode == MC_WorkMode_Run)
	{
		MC_Fault_SpeedSensor_Process(MC_RunInfo.BikeSpeed, 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.Cadence_Data, &MC_ErrorCode);

	//相线故障检测
	MC_Fault_PhaseLine_Process(MC_CalParam.Foc_Flag, MC_RunInfo.BusCurrent, ADC_3ShuntCurrent, &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, &MC_ErrorCode);

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