motor_ctl-3/User/Src/tasks.c

#include <stdbool.h>
#include "tasks.h"
#include "iwdg.h"
#include "gpio.h"
#include "tim.h"
#include "can_process.h"
#include "uart_process.h"
#include "eeprom_24c02.h"
#include "eeprom_flash.h"
#include "adc.h"
#include "hall_sensor.h"
#include "torque_sensor.h"
#include "gas_sensor.h"
#include "math_tools.h"
#include "remain_distance.h"
#include "protect_check.h"
#include "fault_check.h"
#include "key_driver.h"
#include "encrypt.h"
#include "ICM20600.h"
#include "enviolo_can.h"
#include "light_driver.h"

/************************全局变量************************/
TrueOrFalse_Flag_Struct_t IsInitFinish_Flag = FALSE;
To_Te_SendStep IsSendDataToTE_Step = HANDSHAKE;
/**************************局部函数定义*********************/


/**************************全局函数定义*********************/
//1ms任务处理函数
void HAL_SYSTICK_Callback(void)
{
	static uint16_t TimeCnt_5ms = 0;
	static uint16_t TimeCnt_10ms = 0;
	static uint16_t TimeCnt_50ms = 0;
	static uint16_t TimeCnt_100ms = 0;
	static uint16_t TimeCnt_200ms = 0;
	static uint16_t TimeCnt_1000ms = 0;
	
	if(IsInitFinish_Flag == FALSE)
	{
	  return;
	}

	//踏频传感器采集及计算
	CadenceSensor_Process(&MC_CadenceResult, MC_ConfigParam1.StopTime, (MC_ConfigParam1.CadenceStarNum == 0) ? 2 : MC_ConfigParam1.CadenceStarNum, Bike_Attitude.UpWardSlope_flag);
	
	//踏频传感器故障检测
	if(MC_WorkMode == MC_WorkMode_Run)
	{
	  MC_Fault_CadenceSensor_Process(ADC_SensorData.TorqueSensor, MC_RunInfo.BikeSpeed, &MC_ErrorCode);
	}
	
	//根据电机工作模式(MC_WorkMode)、力矩传感器和指拨AD值(ADC_SensorData)、控制档位(MC_ControlCode.GearSt)计算控制FOC输入值(MC_CalParam)
	MC_CalParam_Cal(MC_WorkMode, ADC_SensorData, MC_ControlCode.GearSt, IsBreakTrig_Flag, IsGearSensorTrig_Flag, &MC_CalParam);
	
	//更新控制参数备份值
	Update_MC_CalParam_Back();
	
	//更新力矩传感器零点值
	if(IsTorqueOffSetUpdateEnable == TRUE)
	{
		TorqueOffSetData_Present_Update(&TorqueOffSetData.PresentData, ADC1_Result[ADC1_RANK_TORQUE_SENSOR], MC_TorqueCorrectParam.K, &MC_ErrorCode);
	}
		
	//更新指拨零点值
	if(IsGasSensorConnectedFlag == TRUE)
	{
		GasSensorOffSetData_Update(&GasSensor_OffSet, ADC1_Result[ADC1_RANK_GAS], &MC_ErrorCode);
	}
	
	//ADC数据滑动滤波计算
	ADC_SensorData_Filt(ADC1_Result_Filt, ADC2_Result_Filt);
	
	//发送给TE的传感器数据采集
	MC_TE_SensorScan(&MC_TE_SensorData);
	
	//5ms任务
	TimeCnt_5ms++;
	if(TimeCnt_5ms >= 5)
	{
	  TimeCnt_5ms = 0;
		ICM20600Sensor.UpdateEn = ENABLE;
	}	

	//10ms任务
	TimeCnt_10ms++;
	if(TimeCnt_10ms >= 10)
	{
	  TimeCnt_10ms = 0;

	}
	
	//50ms任务
	TimeCnt_50ms++;
	if(TimeCnt_50ms >= 50)
	{
	  TimeCnt_50ms = 0;
		//计算TE同步时钟频率
    Cal_SyncClockFreq(&MC_TE_SyncClockFreqScan);
	}
	
	//100ms任务
	TimeCnt_100ms++;
	if(TimeCnt_100ms >= 100)
	{
	  TimeCnt_100ms = 0;
	  //踏频计算滑动均值滤波
	  MC_RunInfo.Cadence = MovingAverageFilter(MC_CadenceResult.Cadence_Data, MC_Cadence_Array, sizeof(MC_Cadence_Array) / 2);
	}
	
	//200ms任务
	TimeCnt_200ms++;
	if(TimeCnt_200ms >= 200)
	{
		TimeCnt_200ms = 0;
		//发送打开自动变速器的指令
		if((MC_ConfigParam1.SpeedSignal == MC_SPEED_COMMUNICATION)&&(MC_WorkMode == MC_WorkMode_Run))//当配置速度信号来源于自动变速器
		{
			sendDataToEnviolo(&EnvioloSetData, &Enviolo_Calibration);
			sendDataToOBC(Enviolo_Calibration.u8CalibrationCmdToOBC);
			if((CanEnvioloData.u16Timeout_Communication < COMMUNICATION_TIMEOUT) && (MC_CadenceResult.Cadence_Data >= 5) && (MC_CadenceResult.Cadence_Dir == MC_Cadence_Forward))//10S超时
			{
				CanEnvioloData.u16Timeout_Communication++;
			}
		}
	}
	
	//1000ms任务
	TimeCnt_1000ms++;
	if(TimeCnt_1000ms >= 1000)
	{
	  TimeCnt_1000ms = 0;
		
	}
}

//CAN数据解析函数
void CanRx_Process(void)
{
  CAN_RxData_Process(&CAN_RxBuf_Struct_PBU, 500);
	CAN_RxData_Process(&CAN_RxBuf_Struct_BMS, 500);
	CAN_RxData_Process(&CAN_RxBuf_Struct_HMI, 500);
	CAN_RxData_Process(&CAN_RxBuf_Struct_CDL, 500);
}

//UART数据解析函数
void UartRx_Process(void)
{
  Uart_RxData_Process(&UART_RxBuff_Struct3, 500);
}

//MC运行信息更新
void MC_RunInfo_Update(void)
{
  static uint32_t PeriodTimeCnt = 0;
		
	if((HAL_GetTick() - PeriodTimeCnt) >= 200)
	{
	  PeriodTimeCnt = HAL_GetTick();
		
		//计算电功率
		MC_RunInfo.Power = ((uint32_t)MC_RunInfo.BusCurrent) * 25 / (MC_ConfigParam1.CurrentLimit * 100);
		MC_RunInfo.Power = (MC_RunInfo.Power < 20) ? 0 : MC_RunInfo.Power;
		
		//更新踏频方向
		MC_RunInfo.CadenceDir = MC_CadenceResult.Cadence_Dir;
		
		//计算力矩值
		MC_RunInfo.Torque = ADC_SensorData.TorqueSensor / 28;
		
		//当前助力档位
		MC_RunInfo.GearSt = MC_ControlCode.GearSt;
		
		//当前灯开关
		MC_RunInfo.LightSwitch = MC_ControlCode.LightSwitch;
		
		//剩余电量
		MC_RunInfo.SOC = (DeviceOnLine_Status.Status_Bit.BMS_OffLine == 1) ? Battery_SocCal(MC_RunInfo.BusVoltage * 36 / MC_MotorParam.Rate_Voltage)
	                                                                     : BMS_RunInfo.SOC;
		//续航里程
		MC_RunInfo.RemainDistance = (DeviceOnLine_Status.Status_Bit.BMS_OffLine == 1) ? 0xEEEE : RemainDis.remainDistance;
		
		//骑行总里程计算
		static uint32_t WheelTurnCount = 0;
    static FlagStatus RefreshFlag = RESET;
		
		static uint16_t Array[50];
		static uint8_t i = 0;
		static bool BArrayFullFalg = false;
		static float u16TempData;
		static float DistanceCount_Old = 0;
		static float DistanceCount_Current = 0;

		if(MC_ConfigParam1.SpeedSignal == MC_SPEED_COMMUNICATION) //根据通信获取的车轮旋转周期计算
		{
			if(BArrayFullFalg == false)
			{
				Array[i++] = MC_RunInfo.BikeSpeed;
				u16TempData = MovingAverageFilter(MC_RunInfo.BikeSpeed, Array, i)*0.1;//50次的平均速度   km/h
				
				
				DistanceCount_Current  = DistanceCount_Current + u16TempData/18;//速度(KM/H)*200ms =  ((u16TempData)*1000/3600000)*200 = u16TempData/180 M
				if((DistanceCount_Current - DistanceCount_Old) >= 100) //大于0.1
				{
					DistanceCount_Old = DistanceCount_Current;
					RefreshFlag = SET;
				}
				if(i >= 50)
				{
					BArrayFullFalg = true;
					i = 0;
				}
			}
			else
			{
					u16TempData = MovingAverageFilter(MC_RunInfo.BikeSpeed, Array, sizeof(Array)/2);//50次的平均速度   km/h
					DistanceCount_Current  = DistanceCount_Current + u16TempData/180;//速度(KM/H)*200ms =  ((u16TempData)*1000/3600000)*200 = u16TempData/180 M
					if((DistanceCount_Current - DistanceCount_Old) >= 100) //大于0.1
					{
						DistanceCount_Old = DistanceCount_Current;
						RefreshFlag = SET;
					}
					//MC_RideLog.TRIP_Km = MC_RideLog.TRIP_Km + (u16TempData/180);	//TempData* 0.1 * 200;   (TempData* 0.1)KM/H-->   
			}
		}
		
		else
		{
			if(MC_ConfigParam1.SpeedSignal == MC_SPEED_CADENCE_CAL) //根据踏频计算   
			{
				//车轮转过的圈数 = 踏频信号个数 / 120 * 2.4 * 前飞齿数 / 后飞齿数
				MC_SpeedSensorData.WheelTurnCount = MC_CadenceResult.TrigCount * MC_ConfigParam1.TeethNum_F / MC_ConfigParam1.TeethNum_B / 50;
			}
			else
			{
				//车轮转过的圈数在速度传感器中断已处理
			}
			
			if((MC_SpeedSensorData.WheelTurnCount - WheelTurnCount) >= (10000 / (MC_ConfigParam1.WheelSize + MC_ConfigParam1.WheelSizeAdj))) //0.1km车轮所需圈数
			{	 
				RefreshFlag = SET;
				WheelTurnCount = MC_SpeedSensorData.WheelTurnCount;
			}
		}
		
   if(RefreshFlag == SET)
   {
			RefreshFlag = RESET;
			
			//更新骑行历史信息中ODO和TRIP里程
			MC_RideLog.ODO_Km++;
		  #if 0 //总里程是否自动归零
		  if(MC_RideLog.ODO_Km > 999999)
			{
			  MC_RideLog.ODO_Km = 0;
				MC_RideLog.ODO_Time = 0;
			}
		  #endif
			MC_RideLog.TRIP_Km++;	
		  if(MC_RideLog.TRIP_Km > 99999)  //超过9999.9km清零
			{
			  MC_RideLog.TRIP_Km  = 0;
				MC_RideLog.TRIP_Time = 0;
			}
			//更新运行信息中里程信息 
			MC_RunInfo.Ride_Km++;
			MC_RunInfo.ODO_Km = MC_RideLog.ODO_Km / 10;
			
			#if 1 //自动存储骑行里程
			static uint8_t SavePeriodCount = 0;
			SavePeriodCount++;
			if(SavePeriodCount >= 30)//存储周期为3km
			{
				SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt);
				SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RIDE_LOG, sizeof(MC_RideLog_Struct_t), (uint8_t*)&MC_RideLog.ODO_Km);
				SavePeriodCount = 0;
			}
			#endif
    }

		//骑行时间计算
	  static uint8_t Period_1sCnt = 0;
    static uint8_t Period_1minCnt = 0;
		static uint16_t SavePeriod_Cnt = 0;
		if(MC_RunInfo.BikeSpeed >= 30)
		{
		  Period_1sCnt++;
			if(Period_1sCnt >= 5)  //运行周期为200ms，计时周期200 * 5 = 1s
			{
			  Period_1sCnt = 0;
				SavePeriod_Cnt++;
				MC_RunInfo.Ride_Time++;
				Period_1minCnt++;
			}
		}
		else
		{
		  Period_1sCnt = 0;
		}
		if(Period_1minCnt >= 60)  //1min
		{
	  	Period_1minCnt = 0;
			//更新骑行历史信息中骑行时间
	  	MC_RideLog.ODO_Time++;
			#if 0 //时间是否自动归零
			MC_RideLog.ODO_Time = (MC_RideLog.ODO_Time > 599999) ? 0 : MC_RideLog.ODO_Time;   //超过9999h59min，清零
			MC_RideLog.TRIP_Time = (MC_RideLog.TRIP_Time > 599999) ? 0 : MC_RideLog.TRIP_Time;//超过9999h59min，清零
			#endif
			MC_RideLog.TRIP_Time++;
		}
		//存储骑行总时间
		if(SavePeriod_Cnt >= 600)  //累计骑行600s进行存储
		{
		  SavePeriod_Cnt = 0;
			SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt);
      SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RIDE_LOG, sizeof(MC_RideLog_Struct_t), (uint8_t*)&MC_RideLog.ODO_Km);
		}
		
		//平均功耗
		MC_RunInfo.PowerPerKm = RemainDis.Power_per_km_result / 10;
		
	}
}

//MC故障码发送
void MC_SendErrorCode_Process(MC_ErrorCode_Struct_t ErrorCode)
{
  static uint32_t PeriodTimeCnt = 0;
	
	if(IsSendDataToTE_Step == SENDUPDATA)
	{
	  return;
	}
	
	if(ErrorCode.Code != 0x00000000)
	{
	  if((HAL_GetTick() - PeriodTimeCnt) > 500)
		{
		  PeriodTimeCnt = HAL_GetTick();
			SendData(ID_MC_BC, MODE_REPORT, 0x1104, (uint8_t*)&ErrorCode.Code);
		}
	}
	else
	{
	  PeriodTimeCnt = HAL_GetTick();
	}
}

//MC主动发送运行信息
void MC_SendRunInfo_Process(MC_WorkMode_Struct_t WorkMode)
{
  static uint32_t PeriodTimeCnt = 0;
	
	if(WorkMode == MC_WorkMode_Config)
	{
	  if((HAL_GetTick() - PeriodTimeCnt) >= 200)
		{
		  SendData(ID_MC_BC, MODE_REPORT, 0x1020, (uint8_t*)&MC_RunInfo.BikeSpeed);
			PeriodTimeCnt = HAL_GetTick();
		}
	}
	else
	{
	  PeriodTimeCnt = HAL_GetTick();
	}
}

//发给TE的传感器数据扫描
void MC_TE_SensorScan(MC_TE_SensorData_Struct_t* p_MC_TE_SensorData)
{
  static GPIO_PinState Cadence_Hall_1;
	static GPIO_PinState Cadence_Hall_2;
	static GPIO_PinState Motor_Hall_A;
	static GPIO_PinState Motor_Hall_B;
	static GPIO_PinState Break;
	static GPIO_PinState SpeedSensor;
	static TrueOrFalse_Flag_Struct_t IsFirstEnterFalg = TRUE;
	GPIO_PinState GPIO_PinState_Temp;
	
	//初始化变量
	if(IsFirstEnterFalg == TRUE)
	{
	  Cadence_Hall_1 = HAL_GPIO_ReadPin(CADENCE_1_GPIO_Port, CADENCE_1_Pin);
		Cadence_Hall_2 = HAL_GPIO_ReadPin(CADENCE_2_GPIO_Port, CADENCE_2_Pin);
		Motor_Hall_A = HAL_GPIO_ReadPin(HALL_A_GPIO_Port, HALL_A_Pin);
		Motor_Hall_B = HAL_GPIO_ReadPin(HALL_B_GPIO_Port, HALL_B_Pin);
		Break = HAL_GPIO_ReadPin(BREAK_LEFT_GPIO_Port, BREAK_LEFT_Pin);
		SpeedSensor = HAL_GPIO_ReadPin(SPEED_SENSOR_GPIO_Port, SPEED_SENSOR_Pin);
		p_MC_TE_SensorData->CadenceHall_1_Cnt = 0;
		p_MC_TE_SensorData->CadenceHall_2_Cnt = 0;
		p_MC_TE_SensorData->MotorHall_A_Cnt = 0;
		p_MC_TE_SensorData->MotorHall_B_Cnt = 0;
		p_MC_TE_SensorData->BreakTrgiCnt = 0;
		p_MC_TE_SensorData->SpeedSensorTrigCnt = 0;
		IsFirstEnterFalg = FALSE;
	}
	
	//ADC数据更新采集
	p_MC_TE_SensorData->AD_BusCurrent = ADC1_Result_Filt[ADC1_RANK_CURRENT];
	p_MC_TE_SensorData->AD_CoilTemp = ADC1_Result_Filt[ADC1_RANK_NTC_COIL];
	p_MC_TE_SensorData->AD_TE_Voltage = ADC1_Result_Filt[ADC1_RANK_3V3_TE];
	p_MC_TE_SensorData->AD_Torque = ADC1_Result_Filt[ADC1_RANK_TORQUE_SENSOR];
	
	//踏频霍尔1
	GPIO_PinState_Temp = HAL_GPIO_ReadPin(CADENCE_1_GPIO_Port, CADENCE_1_Pin);
	if(Cadence_Hall_1 != GPIO_PinState_Temp)
	{
	  p_MC_TE_SensorData->CadenceHall_1_Cnt++;
	}
	Cadence_Hall_1 = GPIO_PinState_Temp;
	//踏频霍尔2
	GPIO_PinState_Temp = HAL_GPIO_ReadPin(CADENCE_2_GPIO_Port, CADENCE_2_Pin);
	if(Cadence_Hall_2 != GPIO_PinState_Temp)
	{
	  p_MC_TE_SensorData->CadenceHall_2_Cnt++;
	}
	Cadence_Hall_2 = GPIO_PinState_Temp;
	//马达霍尔A
	GPIO_PinState_Temp = HAL_GPIO_ReadPin(HALL_A_GPIO_Port, HALL_A_Pin);
	if(Motor_Hall_A != GPIO_PinState_Temp)
	{
	  p_MC_TE_SensorData->MotorHall_A_Cnt++;
	}
	Motor_Hall_A = GPIO_PinState_Temp;
	//马达霍尔B
	GPIO_PinState_Temp = HAL_GPIO_ReadPin(HALL_B_GPIO_Port, HALL_B_Pin);
	if(Motor_Hall_B != GPIO_PinState_Temp)
	{
	  p_MC_TE_SensorData->MotorHall_B_Cnt++;
	}
	Motor_Hall_B = GPIO_PinState_Temp;
	//刹车
	GPIO_PinState_Temp = HAL_GPIO_ReadPin(BREAK_LEFT_GPIO_Port, BREAK_LEFT_Pin);
	if(Break != GPIO_PinState_Temp)
	{
	  p_MC_TE_SensorData->BreakTrgiCnt++;
	}
	Break = GPIO_PinState_Temp;
	//速度传感器
	GPIO_PinState_Temp = HAL_GPIO_ReadPin(SPEED_SENSOR_GPIO_Port, SPEED_SENSOR_Pin);
	if(SpeedSensor != GPIO_PinState_Temp)
	{
	  p_MC_TE_SensorData->SpeedSensorTrigCnt++;
	}
	SpeedSensor = GPIO_PinState_Temp;
	//同步时钟频率
	p_MC_TE_SensorData->SynC_Clock_Freq = 1000; //1000KHz
}

//发给TE的传感器数据处理
void MC_TE_SensorData_Process(MC_TE_SensorData_Struct_t* p_MC_TE_SensorData)
{
  static uint32_t PeriodTimeCnt = 0;
	static uint16_t EnterCnt = 0;
	
	//数据发送
	if((HAL_GetTick() - PeriodTimeCnt) >= 500)
	{
	  //计数超过20 * 500ms = 10s，进行一次清零
		EnterCnt++;
		if(EnterCnt >= 20)
		{
		  if(MC_TE_SensorStatus.TE_ErrorCode.Status_Bit.BikeSpeed == 0)
			{
				MC_TE_SensorData.SpeedSensorTrigCnt = 0;
			}
			if(MC_TE_SensorStatus.TE_ErrorCode.Status_Bit.StopBreak == 0)
			{
				MC_TE_SensorData.BreakTrgiCnt = 0;
			}
			if(MC_TE_SensorStatus.TE_ErrorCode.Status_Bit.CadenseSensor_1 == 0)
			{
				MC_TE_SensorData.CadenceHall_1_Cnt = 0;
			}
			if(MC_TE_SensorStatus.TE_ErrorCode.Status_Bit.CadenseSensor_2 == 0)
			{
				MC_TE_SensorData.CadenceHall_2_Cnt = 0;
			}
			if(MC_TE_SensorStatus.TE_ErrorCode.Status_Bit.HallSensor_A == 0)
			{
				MC_TE_SensorData.MotorHall_A_Cnt = 0;
			}
			if(MC_TE_SensorStatus.TE_ErrorCode.Status_Bit.HallSensor_B == 0)
			{
				MC_TE_SensorData.MotorHall_B_Cnt = 0;
			}
			HAL_GPIO_TogglePin(SYC_IO_GPIO_Port, SYC_IO_Pin);
			EnterCnt = 0;
		}
    //发送
    if(IsSendDataToTE_Step == HANDSHAKE)//发送握手信息到TE,只发送一次
    {
      SendUartDataToTE(&UART_TxBuff_Struct3, 0x07FF, MODE_REPORT, 0x8800, (uint8_t*)NULL);
      IsSendDataToTE_Step = SENDSENSOR;
    }
    else if(IsSendDataToTE_Step == SENDSENSOR)//正常发送数据到TE
    {
      SendUartDataToTE(&UART_TxBuff_Struct3, 0x07FF, MODE_REPORT, 0x1014, (uint8_t*)&p_MC_TE_SensorData->AD_Torque);
    }
		PeriodTimeCnt = HAL_GetTick();
	}
}

//根据踏频和母线电流计算限流系数
uint8_t MC_CadenceLimit_Cal(uint8_t Cadence, uint16_t Current, uint8_t T_Coil)
{
  static uint32_t PeriodTimeCnt = 0;
	static uint32_t IdcFiltSum = 0;
	static uint8_t IdcFiltCnt = 0;  //滤波输入值计算
	static uint16_t IdcFilt = 0;    //滤波结果
	static uint16_t Limit_Cnt = 0;  //限流计时值
	static uint16_t OK_Cnt = 0;     //限流恢复计时值
	static FlagStatus LimitFlag = RESET;
	static uint8_t Result = 100;
	
	if((HAL_GetTick() - PeriodTimeCnt) >= 100)
	{
	  PeriodTimeCnt = HAL_GetTick();
		
		//母线电流滤波
		IdcFiltSum += Current;
		IdcFiltCnt++;
		if(IdcFiltCnt >= 8)
		{
			IdcFilt = IdcFiltSum >> 3;
			IdcFiltCnt = 0;
			IdcFiltSum = 0;
		}
		
		//限流保护计时
		if((Cadence < 70) && (IdcFilt > 6000))
		{
		  Limit_Cnt++;
		}
		else	
		{
		  Limit_Cnt = 0;
		}
		
		//限流恢复计时
		if(((Cadence > 70) || (IdcFilt < 5000)) && (T_Coil < 150))
		{
		  OK_Cnt++;
		}
		else
		{
		  OK_Cnt = 0;
		}
		
		//限流判断
		if(Limit_Cnt > 300)
		{
		  Limit_Cnt = 0;
			LimitFlag = SET;
		}
		
		//限流恢复判断
		if(OK_Cnt > 100)
		{
		  OK_Cnt = 0;
			LimitFlag = RESET;
		}
		
		//限流系数计算
		if(LimitFlag == SET)
		{
		  if(Cadence < 70)
			{
			  Result = 30 + Cadence;
				Result = (Result > 100) ? 100 : Result;
			}
			else
			{
			  Result = 100;
			}
		}
		else
		{
		  Result = 100;
		}
	}
	
	return Result;
}

//接收到关机指令处理
void PowerOff_Process(TrueOrFalse_Flag_Struct_t ReturnEnable)
{
  static FlagStatus SaveFlag = RESET;
	static uint32_t PeriodTimeCnt = 0;
	static uint8_t Count = 0;
	
	//关闭助力档位，关闭车灯
	MC_ControlCode.GearSt = MC_GearSt_OFF;
	MC_ControlCode.LightSwitch = MC_LightSwitch_OFF;
	CanEnvioloData.u8SendConfigDataToEnviolo = SEND_POWEROFF;//停止task200ms的301报文
	Update_MC_ControlCode_Back();
	LightDriver_Process(MC_ConfigParam2.MC_TailLight_Mode, IsBreakTrig_Flag, MC_ControlCode.LightSwitch);
	
	#if 1 //存储到Flash，下次开机时从Flash取出转移到EEPROM
	if(SaveFlag == RESET)
	{
		MC_PowerOffBkp.ODO_Km = MC_RideLog.ODO_Km;
		MC_PowerOffBkp.ODO_Time = MC_RideLog.ODO_Time;
		MC_PowerOffBkp.Trip_Km = MC_RideLog.TRIP_Km;
		MC_PowerOffBkp.Trip_Time = MC_RideLog.TRIP_Time;
		MC_PowerOffBkp.Run_Time = MC_RunLog1.RunTime;
		SaveDataToEEPROM_Flash(EEPROM_FLASH_ADDR_POWEROFF_BKP, (uint8_t*)&MC_PowerOffBkp.ODO_Km, 40);//写入掉电临时保存数据，写入前该区域需擦除为0xFF才能操作成功
		SaveDataToEEPROM_Flash(EEPROM_FLASH_ADDR_POWEROFF_BKP_FLAG, (uint8_t*)"FLAG", 4); //掉电存储的数据标志更新
		SaveFlag = SET;
	}
	#endif
	//发送自动变速器关机指令
	sendDataToEnvioloPwroff();
	//发送关机就绪信号
	SendData(ID_MC_BC, MODE_REPORT, 0x1305, (uint8_t*)"READY");
	
	//等待关机
	if(ReturnEnable == TRUE)
	{
	  return;
	}
	else
	{
		PeriodTimeCnt = HAL_GetTick();
		Count = 0;
	  while(Count < 10)
		{
		  if((HAL_GetTick() - PeriodTimeCnt) > 100)
			{
			  PeriodTimeCnt = HAL_GetTick();
				Count++;
				#if DEBUG
			  HAL_IWDG_Refresh(&hiwdg);
			  #endif
			}
		}
	}
}

//CAN设备PBU、HMI、BMS通信状态检测处理
void MC_CanRxCheck_Process(MC_SupportFlag_Struct_t NoPBU_Flag, MC_SupportFlag_Struct_t NoHMI_Flag, MC_WorkMode_Struct_t WorkMode, MC_GearSt_Struct_t* GearSt)
{
  if((WorkMode == MC_WorkMode_Run) && (NoPBU_Flag == MC_SUPPORT_DISABLE)) //不支持无PBU，且正常运行模式
	{
		//PBU通信状态检测
		if(IsComOK_PBU.IsOK_Flag == TRUE)
		{
			if((HAL_GetTick() - IsComOK_PBU.OK_TrigTime) > 1000)  
			{  
				IsComOK_PBU.IsOK_Flag = FALSE;
				*GearSt = MC_GearSt_OFF;
        Update_MC_ControlCode_Back();
				DeviceOnLine_Status.Status_Bit.PBU_OffLine = 1;
			}
			else
			{
			  DeviceOnLine_Status.Status_Bit.PBU_OffLine = 0;
			}
		}		
		else
		{
		  *GearSt = MC_GearSt_OFF;
      Update_MC_ControlCode_Back();
			DeviceOnLine_Status.Status_Bit.PBU_OffLine = 1;
		}
		
		//HMI通信状态检测
		if(NoHMI_Flag == MC_SUPPORT_ENABLE)
		{
		  DeviceOnLine_Status.Status_Bit.HMI_OffLine = 0;
		}
		else
		{
		  if(IsComOK_HMI.IsOK_Flag == TRUE)
			{
			  if((HAL_GetTick() - IsComOK_HMI.OK_TrigTime) > 1000)  
			  {  
			  	IsComOK_HMI.IsOK_Flag = FALSE;
					DeviceOnLine_Status.Status_Bit.HMI_OffLine = 1;
			  }
				else
				{
				  DeviceOnLine_Status.Status_Bit.HMI_OffLine = 0;
				}
			}
			else
			{
			  DeviceOnLine_Status.Status_Bit.HMI_OffLine = 1;
			}
		}
		
		//BMS通信状态检测
		if(IsComOK_BMS.IsOK_Flag == TRUE)
		{
			if((HAL_GetTick() - IsComOK_BMS.OK_TrigTime) > 1000)  
			{  
				IsComOK_BMS.IsOK_Flag = FALSE;
				DeviceOnLine_Status.Status_Bit.BMS_OffLine = 1;
			}
			else
			{
				DeviceOnLine_Status.Status_Bit.BMS_OffLine = 0;
			}
		}
		else
		{
			DeviceOnLine_Status.Status_Bit.BMS_OffLine = 1;
		}
	}
}

//UART设备TE通信状态检测处理
void MC_UartRxCheck_Process(void)
{
  //TE通信状态检测
	if(IsComOK_TE.IsOK_Flag == TRUE)
	{
		if((HAL_GetTick() - IsComOK_TE.OK_TrigTime) > 2000)  
		{  
			IsComOK_TE.IsOK_Flag = FALSE;
		}
	}
}

//运行总时间计算
void MC_RunTime_Cal(uint32_t* p_Runtime)
{
  static uint32_t PeriodTimeCnt = 0;
	static uint8_t SavePeriodCount = 0;
	
	if((HAL_GetTick()- PeriodTimeCnt) >= 60000)
	{
	  PeriodTimeCnt = HAL_GetTick(); 
		(*p_Runtime)++;
		//存储运行总时间
		SavePeriodCount++;
		if(SavePeriodCount >= 10)  //自动存储周期10min
		{
			SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt);
			SavePeriodCount = 0;
		}
	}
}

//设备授权校验
void MC_DeviceCheck(Device_CheckInfo_Struct_t* p_Device, MC_ErrorCode_Struct_t* p_ErrorCode)
{
	uint32_t SendPeriodTimeCnt = 0;
	uint8_t Send_MAC_ID_Cmd_Count = 0;
	uint8_t Send_Code_Cmd_Count = 0;
	uint8_t CalCodeResult[12];
	uint8_t CheckResult = 0;
	uint16_t Send_CanID;
	uint16_t Send_MAC_ID_Cmd;
	uint16_t Send_Code_Cmd;
	uint8_t DeviceSerial = 0;
	
	//确定校验设备类型
	if(p_Device == &BMS_CheckInfo)
	{
	  DeviceSerial = 1;
	}
	else if(p_Device == &PBU_CheckInfo)
	{
	  DeviceSerial = 2;
	}
	if(p_Device == &HMI_CheckInfo)
	{
	  DeviceSerial = 3;
	}
	
	//根据设备类型定义发送指令
	switch(DeviceSerial)
	{
	  case 1://校验电池
		{
		  p_ErrorCode->ERROR_Bit.Fault_BMS_Check = 1;
			Send_CanID = ID_MC_TO_BMS;
			Send_MAC_ID_Cmd = 0x3100;
			Send_Code_Cmd = 0x3200;
			break;
		}
		case 2://校验按键
		{
		   p_ErrorCode->ERROR_Bit.Fault_PBU_Check = 1;
			Send_CanID = ID_MC_TO_BMS;
			Send_MAC_ID_Cmd = 0x5100;
			Send_Code_Cmd = 0x5200;
			break;
		}
		case 3://校验仪表
		{
		  p_ErrorCode->ERROR_Bit.Fault_HMI_Check = 1;
			Send_CanID = ID_MC_TO_BMS;
			Send_MAC_ID_Cmd = 0x7100;
			Send_Code_Cmd = 0x7200;
			break;
		}
		default:break;
	}
	
	//查询MAC ID,计算校验码,并与查询的授权码比较
	Send_MAC_ID_Cmd_Count = 4;
	SendData(Send_CanID, MODE_READ, Send_MAC_ID_Cmd, (uint8_t*)NULL);
	SendPeriodTimeCnt = HAL_GetTick();
	while(Send_MAC_ID_Cmd_Count)
	{
	  CanRx_Process();
		if(CheckArrayIs0(p_Device->MAC_ID, 12) != 0) //检查是否接收到ID
		{
		  CheckCodeCal(p_Device->MAC_ID, Secret_Key, CalCodeResult);//根据接收的ID计算授权码
			Send_Code_Cmd_Count = 4;
			SendData(Send_CanID, MODE_READ, Send_Code_Cmd, (uint8_t*)NULL);
			SendPeriodTimeCnt = HAL_GetTick();
			while(Send_Code_Cmd_Count)
			{
			  CanRx_Process();
				if(CheckArrayIs0(p_Device->CheckCode, 12) != 0)  ////检查是否接收到授权码
				{
				  if(strncmp((char*)p_Device->CheckCode, (char*)CalCodeResult, 12) == 0)
					{
					  CheckResult = 1;
					}
					Send_MAC_ID_Cmd_Count = 0;
					Send_Code_Cmd_Count = 0;
					break;
				}
				else
				{
					if((HAL_GetTick() - SendPeriodTimeCnt) > 100)
					{
						SendData(Send_CanID, MODE_READ, Send_Code_Cmd, (uint8_t*)NULL);
						Send_Code_Cmd_Count--;
						SendPeriodTimeCnt = HAL_GetTick();
					}
				}
				//看门狗清零
			  #if DEBUG
			  HAL_IWDG_Refresh(&hiwdg);
			  #endif
			}
		}
		else
		{
		  if((HAL_GetTick() - SendPeriodTimeCnt) > 100)
			{
				SendData(Send_CanID, MODE_READ, Send_MAC_ID_Cmd, (uint8_t*)NULL);
				Send_MAC_ID_Cmd_Count--;
				SendPeriodTimeCnt = HAL_GetTick();
			}
		}
		//看门狗清零
		#if DEBUG
		HAL_IWDG_Refresh(&hiwdg);
		#endif
	}

	//根据设备类型输出结果
	switch(DeviceSerial)
	{
	  case 1://校验电池
		{
		  if(CheckResult == 1)
			{
			  p_ErrorCode->ERROR_Bit.Fault_BMS_Check = 0;
			}
			else
			{
			  p_ErrorCode->ERROR_Bit.Fault_BMS_Check = 1;
				MC_RunLog1.BMS_Check_FaultCnt++;
				SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt);
			}
			break;
		}
		case 2://校验按键
		{
		  if(CheckResult == 1)
			{
			  p_ErrorCode->ERROR_Bit.Fault_PBU_Check = 0;
			}
			else
			{
			  p_ErrorCode->ERROR_Bit.Fault_PBU_Check = 1;
				MC_RunLog1.PBU_Check_FaultCnt++;
				SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt);
			}
			break;
		}
		case 3://校验仪表
		{
		  if(CheckResult == 1)
			{
			  p_ErrorCode->ERROR_Bit.Fault_HMI_Check = 0;
			}
			else
			{
			  p_ErrorCode->ERROR_Bit.Fault_HMI_Check = 1;
				MC_RunLog1.HMI_Check_FaultCnt++;
				SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt);
			}
			break;
		}
		default:break;
	}
}

//计算TIM2 ETR采集频率
void Cal_SyncClockFreq(uint16_t* Result)
{
  uint16_t Count = 0;
	
	Count = __HAL_TIM_GET_COUNTER(&htim2);
  *Result = Count * 20 / 1000;//50ms内计数值，单位转换为KHz
  __HAL_TIM_SET_COUNTER(&htim2, 0);
}

//温度历史信息处理
void MC_TemperatureLogProcess(void)
{
  static uint32_t PeriodTimeCnt = 0;
	static uint16_t SavePeriodCnt = 0;
	static TrueOrFalse_Flag_Struct_t DataChangeFlag = FALSE;
	
	if(HAL_GetTick() < 10000)  //开机前10s不处理
	{
	  PeriodTimeCnt = HAL_GetTick();
		return;
	}
	
	if((HAL_GetTick() - PeriodTimeCnt) >= 5000)  //判断周期5s
	{
	  PeriodTimeCnt = HAL_GetTick();
		//PCB温度最小值
		if(MC_RunInfo.T_PCB < MC_RunLog1.T_PCB_Min)
		{
		  MC_RunLog1.T_PCB_Min = MC_RunInfo.T_PCB;
			DataChangeFlag = TRUE;
		}
		//PCB温度最大值
		if(MC_RunInfo.T_PCB > MC_RunLog1.T_PCB_Max)
		{
		  MC_RunLog1.T_PCB_Max = MC_RunInfo.T_PCB;
			DataChangeFlag = TRUE;
		}
		//绕组温度最小值
		if(MC_RunInfo.T_Coil < MC_RunLog1.T_Coil_Min)
		{
		  MC_RunLog1.T_Coil_Min = MC_RunInfo.T_Coil;
			DataChangeFlag = TRUE;
		}
		//绕组温度最大值
		if(MC_RunInfo.T_Coil > MC_RunLog1.T_Coil_Max)
		{
		  MC_RunLog1.T_Coil_Max = MC_RunInfo.T_Coil;
			DataChangeFlag = TRUE;
		}//MCU温度最小值
		if(MC_RunInfo.T_MCU < MC_RunLog1.T_MCU_Min)
		{
		  MC_RunLog1.T_MCU_Min = MC_RunInfo.T_MCU;
			DataChangeFlag = TRUE;
		}
		//MCU温度最大值
		if(MC_RunInfo.T_MCU > MC_RunLog1.T_MCU_Max)
		{
		  MC_RunLog1.T_MCU_Max = MC_RunInfo.T_MCU;
			DataChangeFlag = TRUE;
		}		
		
		//自动存储
		SavePeriodCnt++;
		if((SavePeriodCnt > 12) && (DataChangeFlag == TRUE)) //1min
		{
		  SavePeriodCnt = 0;
			DataChangeFlag = FALSE;
			SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RUN_LOG1, sizeof(MC_RunLog1_Struct_t), (uint8_t*)&MC_RunLog1.PowerOnCnt);	
		}
	}
}

/**************************全局函数定义结束*****************/