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 "light_driver.h"
#include "enviolo_can.h"
#include "light_driver.h"
#include "MC_Globals.h"
#include "MC_FOC_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;
	}

	//踏频传感器采集及计算
	if(VersionIdentifyFinishedFlag == TRUE)
	{
		if(MC_VerInfo.HW_Version[7] < 'C')
	    CadenceSensor_Process1(&MC_CadenceResult, MC_ConfigParam1.StopTime, (MC_ConfigParam1.CadenceStarNum == 0) ? 2 : MC_ConfigParam1.CadenceStarNum, FALSE);
		else
			CadenceSensor_Process2(&MC_CadenceResult, MC_ConfigParam1.StopTime, (MC_ConfigParam1.CadenceStarNum == 0) ? 2 : MC_ConfigParam1.CadenceStarNum, FALSE);
	}	
	
	//踏频传感器故障检测
	if(MC_WorkMode == MC_WorkMode_Run)
	{
	  if(VersionIdentifyFinishedFlag == TRUE)
		{
			if(MC_VerInfo.HW_Version[7] < 'C')
		    MC_Fault_CadenceSensor_Process1(ADC_SensorData.TorqueSensor, MC_RunInfo.BikeSpeed, &MC_ErrorCode);		
			else
				MC_Fault_CadenceSensor_Process2(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;
		
	}	

	//10ms任务
	TimeCnt_10ms++;
	if(TimeCnt_10ms >= 10)
	{
	  TimeCnt_10ms = 0;
      //计算整车传动比
      BikeRatioCal_Process(MC_RunInfo.MotorSpeed, MC_RunInfo.Cadence, MC_RunInfo.BikeSpeed, &Bike_RatioCalParam);

	}
	
	//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;
		
	}
	
	//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();
				
		//计算电功率，额定功率高5位用于显示功率分频系数，低11位额定功率
		if((MC_MotorParam.Rate_Power >> 11) == 0) //旧程序未配
		{
		  MC_RunInfo.Power = ((uint32_t)MC_RunInfo.BusCurrent) * 250 / (MC_ConfigParam1.CurrentLimit * 1000);
		}
		else //新程序高5位为显示最大功率分频系数，最大显示功率 = 配置额定功率 * 分频系数 / 32
		{
		  MC_RunInfo.Power = ((uint32_t)MC_RunInfo.BusCurrent) * (((MC_MotorParam.Rate_Power & 0x07FF) * ((MC_MotorParam.Rate_Power >> 11) + 1)) >> 5) / (MC_ConfigParam1.CurrentLimit * 1000);
		}
		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;
		
		//踩踏功率计算		
		PedalPowerFltSum += (((int32_t)(MC_RunInfo.Cadence * MC_RunInfo.Torque * 107) - PedalPowerFltSum) >> 4);  //P = n * T / 9.55		
		
		//当前助力档位
		MC_RunInfo.GearSt = MC_ControlCode.GearSt;
		
		//当前灯开关
		MC_RunInfo.LightSwitch = MC_ControlCode.LightSwitch;
		
		//剩余电量
		MC_RunInfo.SOC = (DeviceOnLine_Status.Status_Bit.BMS_OffLine == 1) ? Battery_SocCal(&Battery_Info, &BatteryCellInfo, MC_RunInfo.SOC, 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;
		
		if(MC_ConfigParam1.SpeedSignal == MC_SPEED_COMMUNICATION) //根据通信获取的车轮旋转周期计算
		{
		  static uint32_t WheelTurnCount_Temp = 0;
			//运算周期是200ms，根据车轮旋转周期计算200ms内旋转的圈数，存在小数，放大1024倍
			if(MC_SpeedSensorData.IsStopFlag == FALSE)
			{
				WheelTurnCount_Temp += 819200 / MC_SpeedSensorData.DiffTime_ms;
				MC_SpeedSensorData.WheelTurnCount = WheelTurnCount_Temp >> 12;			
			}
		}
		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++;
		  MC_RunLog1.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 0 //自动存储骑行里程
			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++;
			MC_RunLog1.ODO_Time++;
			MC_RideLog.TRIP_Time++;
			#if 0 //时间是否自动归零
			if(MC_RideLog.ODO_Time > 599999)
				MC_RideLog.ODO_Time = 0;
			if(MC_RideLog.TRIP_Info.TripTime_MaxSpeed.TRIP_Time > 599999)
				MC_RideLog.TRIP_Info.TripTime_MaxSpeed.TRIP_Time > 599999 = 0;
			#endif
			//骑行功率累计
			MC_AvgPower.PedalPowerSum += (PedalPowerFltSum >> 10); //Wmin	
		}
		//存储骑行总时间
		#if 0 //根据骑行时间自动存储
		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);		
		}
		#endif
		
		//平均功耗
		MC_RunInfo.PowerPerKm = RemainDis.Power_per_km_result / 10;
		
		//骑行信息计算
		do
		{		
			uint16_t PowerAvg;
	    //最大车速
			if(MC_AvgPower.SpeedMax < MC_RunInfo.BikeSpeed)
				MC_AvgPower.SpeedMax = MC_RunInfo.BikeSpeed;
			MC_RideInfo.SpeedMax = MC_AvgPower.SpeedMax;
			//平均车速
			if(MC_RideLog.TRIP_Time == 0)
				MC_RideInfo.SpeedAvg = 0;
			else
				MC_RideInfo.SpeedAvg = MC_RideLog.TRIP_Km * 60 / MC_RideLog.TRIP_Time;
			//卡路里
			if(MC_RideLog.ODO_Time == 0)
				PowerAvg = 0;
			else
				PowerAvg = MC_AvgPower.PedalPowerSum /  MC_RideLog.ODO_Time;
			MC_RideInfo.Cal_Trip = PowerAvg * 66 * MC_RideLog.TRIP_Time / 1000; //Cal = P * 1.1 * 3.6 * t(h)
			MC_RideInfo.Cal_Once = PowerAvg * 11 * MC_RunInfo.Ride_Time / 10000; //Cal = P * 1.1 * 3.6 * t(h)
		}while(0);	
	}
}

//调试信息更新
void MC_DebugInfo_Update(void)
{
  static uint32_t PeriodTimeCnt = 0;
		
	if((HAL_GetTick() - PeriodTimeCnt) >= 100)
	{
	  PeriodTimeCnt = HAL_GetTick();
		MC_DebugInfo.SysFSM1 = MC_CalParam.AssistRunMode;                 //助力模式
		MC_DebugInfo.SysFSM2 = FOC_Status;                                //FOC状态
		MC_DebugInfo.SysFSM3 = 0;
		MC_DebugInfo.SysFSM4 = 0;
		MC_DebugInfo.IdRef = IdFluxLessRef;                               //IdRef
		MC_DebugInfo.IqRef = IqFluxLessRef;                               //IqRef
		MC_DebugInfo.UdRef = Stat_Volt_q_d.qV_Component2;                 //UdRef
		MC_DebugInfo.UqRef = Stat_Volt_q_d.qV_Component1;                 //UqRef
		MC_DebugInfo.PedalTorquePer = ADC_SensorData.TorqueSensor;        //力矩AD，减去零点
		MC_DebugInfo.PedalTorqueAvg = ADC_SensorData.GasSensor;           //转把AD，减去零点
		MC_DebugInfo.PedalTorqueByCad = MC_CadenceResult.torqueByCadence; //力矩AD，根据踏频滤波
		MC_DebugInfo.IdFdb = IdFdbFlt >> 10;                              //IdFdb
		MC_DebugInfo.IqFdb = IqFdbFlt >> 10;                              //IqFdb
		if(MC_CalParam.AssistRunMode == MC_AssistRunMode_TORQUE)
			MC_DebugInfo.AssistOut = MC_CalParam.Ref_Torque;
		else if(MC_CalParam.AssistRunMode == MC_AssistRunMode_WALK)
			MC_DebugInfo.AssistOut = MC_CalParam.Ref_Speed;
		else if(MC_CalParam.AssistRunMode == MC_AssistRunMode_GAS)
		{
		  if(MC_GasMode_Param.Mode_bit.CrontrolMode == 0)
				MC_DebugInfo.AssistOut = MC_CalParam.Ref_Speed;
			else
				MC_DebugInfo.AssistOut = MC_CalParam.Ref_Torque;
		}
		else
			MC_DebugInfo.AssistOut = 0;			
	}
}

//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();
	}
}

//MC主动发送调试信息
void MC_SendDebugInfo_Process(MC_WorkMode_Struct_t WorkMode)
{
  static uint32_t PeriodTimeCnt = 0;
	
	if(WorkMode == MC_WorkMode_Debug)
	{
	  if((HAL_GetTick() - PeriodTimeCnt) >= 200)
		{
		  SendData(ID_MC_BC, MODE_REPORT, 0x1020, (uint8_t*)&MC_RunInfo.BikeSpeed);
			SendData(ID_MC_TO_CDL, MODE_REPORT, 0xBA20, (uint8_t*)&MC_DebugInfo.SysFSM1);
			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 = 2048;
	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
    {
			//发送指令，TE不控制12V电源
      static uint8_t Count = 0;
      uint8_t Data[1] = {0};
      if(Count++ <= 5)
      {
        SendUartDataToTE(&UART_TxBuff_Struct3, 0x07FF, MODE_WRITE, 0x1301, (uint8_t*)Data);
        HAL_Delay(10);
      }
			
      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;
	Update_MC_ControlCode_Back();
	LightDriver_Process(MC_ConfigParam2.MC_Light_Mode, MC_ConfigParam2.HeadLightVol, MC_ConfigParam2.TailLightVol, 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;
		MC_PowerOffBkp.Log_ODO_Km = MC_RunLog1.ODO_Km;
		MC_PowerOffBkp.Log_ODO_Time = MC_RunLog1.ODO_Time;
		MC_PowerOffBkp.PedalPoweSum = MC_AvgPower.PedalPowerSum;
		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
	//发送关机就绪信号
	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) //不支持无PBU，且正常运行模式
	{
		if( NoPBU_Flag == MC_SUPPORT_DISABLE )
		{
			//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) > 5000)  
			{  
				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()
{
  static uint32_t PeriodTimeCnt = 0;
	static uint32_t SavePeriodCount = 0;
	
	if((HAL_GetTick()- PeriodTimeCnt) >= 60000)
	{
	  PeriodTimeCnt = HAL_GetTick();
		MC_RunLog1.RunTime++;
		SavePeriodCount++;
	}
	//自动存储历史数据
	if(SavePeriodCount >= 10)  //自动存储周期10min
	{
		if(MC_CalParam.Foc_Flag == RESET)
		{
			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);
			SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_AVG_POWER, sizeof(MC_AvgPower_Struct_t), (uint8_t*)&MC_AvgPower.GearSt_ECO);
			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++;
				RunLogSaveIndex = 1;		
			}
			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++;
				RunLogSaveIndex = 1;		
			}
			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++;
				RunLogSaveIndex = 1;		
			}
			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 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;
		}		
		
		//自动存储
		#if 0
		static uint16_t SavePeriodCnt = 0;
		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);	
		}
		#endif
	}
}


//无码表模式初始化处理
void NoPBUMode_Ini( void )
{
	static TrueOrFalse_Flag_Struct_t NoPBUModeIniFinishedFlag = FALSE;
	
	if(HAL_GetTick() > 3000)
	{
		if( NoPBUModeIniFinishedFlag== FALSE )
		{
			NoPBUModeIniFinishedFlag = TRUE;
			if(MC_ConfigParam1.NoPBU_Flag == MC_SUPPORT_ENABLE)
			{
				MC_ControlCode.GearSt = MC_GearSt_SMART;
				Update_MC_ControlCode_Back();
			}
		}
	}
}


//车辆传动比计算，运行周期100ms
void BikeRatioCal_Process(uint16_t MotorSpeed, uint16_t Cadence, uint16_t BikeSpeed, Bike_RatioCal_Struct_t* p_Bike_RatioCal)
{
	uint16_t AccCnt, DecCnt;
	//车辆静止或滑行时不计算
	if((BikeSpeed < 30) || ((BikeSpeed >= 30) && (MotorSpeed < 100) && (Cadence < 10)))
	{
	  p_Bike_RatioCal->RatioPer = p_Bike_RatioCal->RatioDefault;
		p_Bike_RatioCal->RatioResult = p_Bike_RatioCal->RatioDefault;
		p_Bike_RatioCal->RatioFlt = p_Bike_RatioCal->RatioDefault;
		p_Bike_RatioCal->RatioFltSum = 0;
		return;
	}	
	//根据车速、电机转速、踏频计算传动系数，系数 = 车速 / 电机转速 * 1024，其中车速单位为km/h，并放大了10倍
	p_Bike_RatioCal->RatioPer = (((uint32_t)BikeSpeed << 18) * 10) / ((((uint32_t)MotorSpeed << 8) > ((uint32_t)Cadence * 2795)) ? ((uint32_t)MotorSpeed << 8) : ((uint32_t)Cadence * 2795));
	//限制计算结果
	p_Bike_RatioCal->RatioPer = (p_Bike_RatioCal->RatioPer < 500) ? 500 : ((p_Bike_RatioCal->RatioPer > 8000) ? 8000 : p_Bike_RatioCal->RatioPer);
	//计算结果滤波
	p_Bike_RatioCal->RatioFltSum += ((p_Bike_RatioCal->RatioPer << 10) - p_Bike_RatioCal->RatioFltSum) >> 5;
	p_Bike_RatioCal->RatioFlt = p_Bike_RatioCal->RatioFltSum >> 10;
    //目标值计算
	#if 0
    AccCnt = p_Bike_RatioCal->TargetAcc;
	DecCnt = p_Bike_RatioCal->TargetDec;
	if(p_Bike_RatioCal->RatioFlt - p_Bike_RatioCal->RatioResult >= AccCnt)
		p_Bike_RatioCal->RatioResult += AccCnt;
	else if(p_Bike_RatioCal->RatioResult - p_Bike_RatioCal->RatioFlt >= DecCnt)
		p_Bike_RatioCal->RatioResult -= DecCnt;
	else
		p_Bike_RatioCal->RatioResult = p_Bike_RatioCal->RatioFlt;
	#else
	  p_Bike_RatioCal->RatioResult = p_Bike_RatioCal->RatioFlt;
	#endif
}

//设备心跳
void Device_Handshake_Process(void)
{
	static uint32_t PeriodCnt = 0;
	static uint8_t i = 0;
	static uint8_t HandShakeFlag1 = 0, HandShakeFlag2 = 0;
	
	//开机时判断是否发送心跳
	if(HandShakeFlag1 == 0)
	{
	  if(IsComOK_BMS.IsOK_Flag == TRUE)
			HandShakeFlag1 = 1;
	}
	
	if(HandShakeFlag2 == 0)
	{
		if(IsComOK_PBU.IsOK_Flag == TRUE)
				HandShakeFlag2 = 1;
	}
	
	//定时循环发送心跳
	if((HAL_GetTick() - PeriodCnt) >= 1000)
	{
 	  PeriodCnt = HAL_GetTick();
		if(i == 0)
		{
		  //BMS
			if(HandShakeFlag1 == 1)
				SendData(ID_MC_TO_BMS, MODE_READ, 0x3009, (uint8_t*)"HANDSHAKE");
			i = 1;
		}
		else if(i == 1)
		{
		  //OBC
			if(HandShakeFlag2 == 1)
				SendData(ID_MC_TO_PBU, MODE_READ, 0x5009, (uint8_t*)"HANDSHAKE");
			i = 0;
		}
		
	}		
}
/**************************全局函数定义结束*****************/