CN300/Src_app/tasks.c

#include "tasks.h"
#include "usart.h"
#include "key_drivers.h"
#include "tim.h"
#include "var.h"
/************************è???±?á?************************/
uint8_t		PowerOn_flag=0;
uint16_t	MC_error_cnt=0;
uint16_t  BMS_Charging_count=0;
uint16_t 	TE_Sync_Clock_Freq=1000, MCU_FreqResult=0;
/************************全局变量End*********************/

/************************局部函数定义********************/
static void PowerKey_Process(void)
{
	Key_Check(&Key_On_Off, 10);
	//Key_On_Off按键处理
	if( Key_On_Off.KeyStatus != Key_Status_NoPress )		
	{
	  if(Key_On_Off.KeyStatus == Key_Status_ShortPress)//短按
		{
		   Key_On_Off.KeyStatus = Key_Status_NoPress;
			//按键测试模式，按键置位
			if(PBU_RunMode == PBU_RunMode_CDL_KeyTest)
		  {
				PBU_Test_Process.KeyTest_Status.Status_Bit.Power = 1;
			}
		}
		else if(Key_On_Off.KeyStatus == Key_Status_LongPress)//长按
		{
		  Key_On_Off.KeyStatus = Key_Status_NoPress;
			//任意模式下，关机处理
			//按键测试模式，按键置位
			if(PBU_RunMode == PBU_RunMode_CDL_KeyTest)
		  {
				PBU_Test_Process.KeyTest_Status.Status_Bit.Power = 1;
			}
			else
			{
				if(PBU_PowerOn_Process.PowerKeyStatus == 2)
				{
						//系统关机处理，广播发送ShudDown指令，收到所有设备的Ready信号或超时关机
					LED_Blink_Enable = 0x00;					
					PBU_RunMode = PBU_RunMode_PowerOff;
					PBU_PowerOff_Process.DelayTimeCnt = SysTime_5ms;
					PBU_PowerOff_Process.SendCodeTimeCnt = 0;
				}
			}
		}
	}	
}
	
static void LightKey_Process(void)
{
	Key_Check(&Key_Light,120);
	//Key_Light按键处理
	if(Key_Light.KeyStatus != Key_Status_NoPress )
	{
	  if(Key_Light.KeyStatus == Key_Status_ShortPress)//短按
		{
		    Key_Light.KeyStatus = Key_Status_NoPress;
			//按键测试模式，按键置位
			if(PBU_RunMode == PBU_RunMode_CDL_KeyTest)
			{
			    PBU_Test_Process.KeyTest_Status.Status_Bit.Light = 1;
			}
			//助力控制模式，调节灯光
			else if(PBU_RunMode == PBU_RunMode_MC_AssisitCtrl)
			{
			    if(ControlCode.LightSwitch == 0xF1)
				{
				    ControlCode.LightSwitch = 0xF0;
				}
				else
				{
				    ControlCode.LightSwitch = 0xF1;
				}
			}
			else if(PBU_HMI_Menu_Process.HMI_ACK_Flag == TRUE)
			{
				if(ControlCode.LightSwitch == 0xF1)
				{
				    ControlCode.LightSwitch = 0xF0;
				}
				else
				{
				    ControlCode.LightSwitch = 0xF1;
				}
				PBU_HMI_Menu_Process.KeyTrig_Flag = 1;
				PBU_HMI_Menu_Process.PBU_HMI_KeyStatus.Key_Light = Key_Status_ShortPress;
			}
		}
		else if(Key_Light.KeyStatus == Key_Status_LongPress)//长按
		{
		    Key_Light.KeyStatus = Key_Status_NoPress;
		}
	}
}

static void _Task_KeyScan(void)
{	
	//按键判断
	Key_Check(&Key_Walk,120);
	Key_Check(&Key_Down,120);
	Key_Check(&Key_Up,120);

			
	if((ADC_Result[4]+ADC_Result[2]+ADC_Result[5])<5000)
	{
		KeyParamInit_no_cont(&Key_Walk);
		KeyParamInit_no_cont(&Key_Down);	
		KeyParamInit_no_cont(&Key_Up);
	}
		
	if( (PBU_ErrorCode.Code!=0)||(MC_ErrorCode.Code!=0))
	{	
		Error_Init();
		KeyParamInit(&Key_Walk);	
		KeyParamInit(&Key_Down);
		KeyParamInit(&Key_Up);
	}
	else if(BMS_ChargingFlag == TRUE)//电池充电
	{
		Error_Init();
		KeyParamInit(&Key_Walk);	
		KeyParamInit(&Key_Down);
		KeyParamInit(&Key_Up);
	}
	else
  {
		//Key_Walk按键处理
		if( Key_Walk.KeyStatus != Key_Status_NoPress )
		{
			if(Key_Walk.KeyStatus == Key_Status_ShortPress)//短按
			{
					Key_Walk.KeyStatus = Key_Status_NoPress;
				//按键测试模式，按键置位
				if(PBU_RunMode == PBU_RunMode_CDL_KeyTest)
				{
						PBU_Test_Process.KeyTest_Status.Status_Bit.Walk = 1;
				}
				//助力控制模式，进入推行助力等待
				else if(PBU_RunMode == PBU_RunMode_MC_AssisitCtrl)
				{
					if(PBU_AssitMode_Status.PBU_AssistMode_Flag == PBU_AssistMode_Flag_WalkSby)//推行等待模式下，退出到进入前档位
					{
						if(PBU_AssitMode_Status.IsSmartEtrWalk_Flag == TRUE)
						{
							PBU_AssitMode_Status.PBU_AssistMode_Flag = PBU_AssistMode_Flag_Smart;
							PBU_AssitMode_Status.IsSmartEtrWalk_Flag = FALSE;
							PBU_AssitMode_Status.PBU_WalkSbyProcess.DelayTimeCnt = SysTime_5ms;
							PBU_AssitMode_Status.PBU_WalkSbyProcess.HMI_ACK_Flag = FALSE;
							PBU_AssitMode_Status.PBU_WalkSbyProcess.SendCodeTimeCnt_WalkSby = 0;						
						}
						else
						{
							PBU_AssitMode_Status.PBU_AssistMode_Flag = PBU_AssistMode_Flag_Gear;
							PBU_AssitMode_Status.PBU_WalkSbyProcess.DelayTimeCnt = SysTime_5ms;
							PBU_AssitMode_Status.PBU_WalkSbyProcess.HMI_ACK_Flag = FALSE;
							PBU_AssitMode_Status.PBU_WalkSbyProcess.SendCodeTimeCnt_WalkSby = 0;						
						}
					}
					else//进入推行等待
					{
						if(PBU_AssitMode_Status.PBU_AssistMode_Flag == PBU_AssistMode_Flag_Smart)
						{
							 PBU_AssitMode_Status.IsSmartEtrWalk_Flag = TRUE;
						}
						else
						{
							 PBU_AssitMode_Status.IsSmartEtrWalk_Flag = FALSE;
						}
						PBU_AssitMode_Status.PBU_AssistMode_Flag = PBU_AssistMode_Flag_WalkSby;
						PBU_AssitMode_Status.GearStBak_Walk = ControlCode.GearSt;
						PBU_AssitMode_Status.WalkDelayTimeCnt = SysTime_5ms;
						PBU_AssitMode_Status.PBU_WalkSbyProcess.SendCodeTimeCnt_WalkSby = 0;
						PBU_AssitMode_Status.PBU_WalkSbyProcess.HMI_ACK_Flag = FALSE;
						PBU_AssitMode_Status.PBU_WalkSbyProcess.DelayTimeCnt = SysTime_5ms;
					}
				}
			}
			else if(Key_Walk.KeyStatus == Key_Status_LongPress)//长按
			{
					Key_Walk.KeyStatus = Key_Status_NoPress;
			}
		}
		//Key_Down按键处理
		if(Key_Down.KeyStatus != Key_Status_NoPress )
		{
				if(Key_Down.KeyStatus == Key_Status_ShortPress)//短按
			{
					Key_Down.KeyStatus = Key_Status_NoPress;
				//按键测试模式，按键置位
				if(PBU_RunMode == PBU_RunMode_CDL_KeyTest)
				{
						PBU_Test_Process.KeyTest_Status.Status_Bit.Dec = 1;
				}
				//助力控制模式，调节档位、退出Smart模式、退出推行模式
				else if(PBU_RunMode == PBU_RunMode_MC_AssisitCtrl)
				{
					if(PBU_AssitMode_Status.PBU_AssistMode_Flag == PBU_AssistMode_Flag_Gear)
					{
						if(ControlCode.GearSt > 0)
						{
							ControlCode.GearSt--;
							PBU_AssitMode_Status.GearStBak_Smart--;
							PBU_AssitMode_Status.GearStBak_Walk--;
						}
					}
					else if(PBU_AssitMode_Status.IsSmartEtrWalk_Flag == TRUE)
					{
							PBU_AssitMode_Status.PBU_AssistMode_Flag = PBU_AssistMode_Flag_Smart;
						PBU_AssitMode_Status.IsSmartEtrWalk_Flag = FALSE;
						PBU_AssitMode_Status.PBU_WalkSbyProcess.DelayTimeCnt = SysTime_5ms;
							PBU_AssitMode_Status.PBU_WalkSbyProcess.HMI_ACK_Flag = FALSE;
						PBU_AssitMode_Status.PBU_WalkSbyProcess.SendCodeTimeCnt_WalkSby = 0;
					}
					else
					{
							PBU_AssitMode_Status.PBU_AssistMode_Flag = PBU_AssistMode_Flag_Gear;
						PBU_AssitMode_Status.PBU_WalkSbyProcess.DelayTimeCnt = SysTime_5ms;
						PBU_AssitMode_Status.PBU_WalkSbyProcess.HMI_ACK_Flag = FALSE;
						PBU_AssitMode_Status.PBU_WalkSbyProcess.SendCodeTimeCnt_WalkSby = 0;
					}
				}
			}
			else if(Key_Down.KeyStatus == Key_Status_LongPress)//长按
			{
					Key_Down.KeyStatus = Key_Status_NoPress;
				//助力控制模式，调节档位、退出Smart模式、退出推行模式
				if(PBU_RunMode == PBU_RunMode_MC_AssisitCtrl)
				{
					if(PBU_AssitMode_Status.IsSmartEtrWalk_Flag == TRUE)
					{
						PBU_AssitMode_Status.PBU_AssistMode_Flag = PBU_AssistMode_Flag_Smart;
						PBU_AssitMode_Status.IsSmartEtrWalk_Flag = FALSE;
					}
					else
					{
						PBU_AssitMode_Status.PBU_AssistMode_Flag = PBU_AssistMode_Flag_Gear;
					}
				}
			}
		}
		//Key_Up按键处理
		if(Key_Up.KeyStatus != Key_Status_NoPress )
		{
			#if 0 //长按进入SMART，短按退出
			if(Key_Up.KeyStatus == Key_Status_ShortPress)//短按
			{
					Key_Up.KeyStatus = Key_Status_NoPress;
				//按键测试模式，按键置位
				if(PBU_RunMode == PBU_RunMode_CDL_KeyTest)
				{
						PBU_Test_Process.KeyTest_Status.Status_Bit.Add = 1;
				}
				//助力控制模式，调节档位
				else if(PBU_RunMode == PBU_RunMode_MC_AssisitCtrl)
				{
						if(PBU_AssitMode_Status.PBU_AssistMode_Flag == PBU_AssistMode_Flag_Gear)
					{
							if(ControlCode.GearSt < PBU_ConfigParam.GearsNum)
						{
								ControlCode.GearSt++;
							PBU_AssitMode_Status.GearStBak_Smart++;
							PBU_AssitMode_Status.GearStBak_Walk++;
						}
					}
					else if(PBU_AssitMode_Status.PBU_AssistMode_Flag == PBU_AssistMode_Flag_Smart)
					{
							PBU_AssitMode_Status.PBU_AssistMode_Flag = PBU_AssistMode_Flag_Gear;
					}
				}
			}
			else if(Key_Up.KeyStatus == Key_Status_LongPress)//长按
			{
					Key_Up.KeyStatus = Key_Status_NoPress;
				//助力控制模式，进入i-Sport
				if(PBU_RunMode == PBU_RunMode_MC_AssisitCtrl)
				{
						if(PBU_AssitMode_Status.PBU_AssistMode_Flag == PBU_AssistMode_Flag_Gear)
					{
							PBU_AssitMode_Status.PBU_AssistMode_Flag = PBU_AssistMode_Flag_Smart;
						PBU_AssitMode_Status.GearStBak_Smart = ControlCode.GearSt;
					}
					else if(PBU_AssitMode_Status.PBU_AssistMode_Flag == PBU_AssistMode_Flag_Smart)
					{
							PBU_AssitMode_Status.PBU_AssistMode_Flag = PBU_AssistMode_Flag_Gear;
					}
				}
			}
			#else //短按进入SMART
			if(Key_Up.KeyStatus == Key_Status_ShortPress)//短按
			{
					Key_Up.KeyStatus = Key_Status_NoPress;
				//按键测试模式，按键置位
				if(PBU_RunMode == PBU_RunMode_CDL_KeyTest)
				{
						PBU_Test_Process.KeyTest_Status.Status_Bit.Add = 1;
				}
				//助力控制模式，调节档位
				else if(PBU_RunMode == PBU_RunMode_MC_AssisitCtrl)
				{
					if(PBU_AssitMode_Status.PBU_AssistMode_Flag == PBU_AssistMode_Flag_Gear)
					{
						if(ControlCode.GearSt < PBU_ConfigParam.GearsNum) //0~4档
						{
							ControlCode.GearSt++;
							PBU_AssitMode_Status.GearStBak_Smart++;
							PBU_AssitMode_Status.GearStBak_Walk++;
						}
						else //到达4档后再次按下，会一直停留在SMART
						{
							PBU_AssitMode_Status.PBU_AssistMode_Flag = PBU_AssistMode_Flag_Smart;
						  PBU_AssitMode_Status.GearStBak_Smart = ControlCode.GearSt;
						}
					}					
				}
			}
			else if(Key_Up.KeyStatus == Key_Status_LongPress)//长按
			{
			  Key_Up.KeyStatus = Key_Status_NoPress;
				//...
			}
			#endif
	 }
 }
}

//计算MCU同步时钟频率
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);
}

//比较MCU和TE采集的时钟频率
void SyncClockFreq_Judge(uint16_t FreqResult, uint16_t Sync_Clock_Freq)
{
  static uint32_t SyncClockErrorCnt = 0;
   
  if( ( FreqResult < (Sync_Clock_Freq - 200) ) || ( FreqResult > (Sync_Clock_Freq + 200) ) )
  {
		SyncClockErrorCnt++;
    if( SyncClockErrorCnt > 100 )
    {
			SyncClockErrorCnt = 0;
      PBU_TE_ErrorCode.ERROR_Bit.MCU_Fault = 1;
    }
  }
  else
  {
    SyncClockErrorCnt = 0;
  }
}
//static void _Task_ADC_Update(void)
//{
//    int32_t Temp_int32 = 0;
	
	//更新Vref电压
//	MCU_VDDA = 3300 * (*VREFINT_CAL) / ADC_Value_Vin.ADC_Result[ADC_RANK_VREF];
//	ADC_Value_Vin.Voltage[ADC_RANK_VREF] = ADC_Value_Vin.ADC_Result[ADC_RANK_VREF] * MCU_VDDA / 4095;
//	
//	//更新母线电压值结果
//	ADC_Value_Vin.Voltage[ADC_RANK_VIN] = ADC_Value_Vin.ADC_Result[ADC_RANK_VIN] * MCU_VDDA / 4095;
//	Voltage_Vin = ADC_Value_Vin.Voltage[ADC_RANK_VIN] * 16;//300K 20K
//	
//	//更新MCU内部温度
//	#if 1
//	ADC_Value_Vin.Voltage[ADC_RANK_TEMP] = ADC_Value_Vin.ADC_Result[ADC_RANK_TEMP] * MCU_VDDA / 4095;
//	Temp_int32 = (int16_t)(1430 - ADC_Value_Vin.Voltage[ADC_RANK_TEMP]);
//	MCU_Temperature = Temp_int32 * 100 / 430 + 25;
//	#elif 1
//	Temp_int32 = (int32_t)ADC_Value_Vin.ADC_Result[ADC_RANK_TEMP];
//	Temp_int32 = (int32_t)(Temp_int32 * MCU_VDDA * 10 / 33) / 1000;
//	Temp_int32 = Temp_int32 - (int32_t)(*TEMP30_CAL_ADDR);
//	Temp_int32 = Temp_int32 * (int32_t)(110 - 30);
//	Temp_int32 = Temp_int32 / ((int32_t)(*TEMP110_CAL_ADDR)  - (int32_t)(*TEMP30_CAL_ADDR));
//	MCU_Temperature = Temp_int32 + 30;
//	#endif	
//}
/**************************局部函数定义结束*****************/

/**************************全局函数定义*********************/
//超时计数
uint32_t TimeCntDiff_5ms(uint32_t v)
{
    int32_t lDiff;

	lDiff = (int32_t)(SysTime_5ms - v);
	if(lDiff < 0)
	{
		lDiff += ((int32_t)TCNT_1HOUR);
	}

	return (uint32_t)lDiff;
}

//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_1000ms = 0;
	static uint16_t TimeCnt_60000ms = 0;
	
	Scan_Key_ADC_Error();
//	Vin_test_Check();	
	
	//5ms任务
	TimeCnt_5ms++;
	if(TimeCnt_5ms >= 5)
	{
	  TimeCnt_5ms = 0;
		SysTime_5ms++;
	}
	if(SysTime_5ms > TCNT_1HOUR)
	{
	  SysTime_5ms = 0;
	}
	
	//10ms任务
	TimeCnt_10ms++;
	if(TimeCnt_10ms >= 10)
	{
	  TimeCnt_10ms = 0;
		//按键扫描
		PowerKey_Process();
		if(PBU_ErrorCode.ERROR_Bit.Key_Light == 0) LightKey_Process();
		if(PowerOn_flag==1)
			_Task_KeyScan();
	}

	//50ms任务
	if(PBU_TE_FaultDetectFlag == TRUE)
	{
		TimeCnt_50ms++;
		if(TimeCnt_50ms >= 50)
		{
			TimeCnt_50ms = 0;
			HAL_GPIO_TogglePin(GPIOA,GPIO_PIN_4);
			Scan_Key_Start=0x01;
			Cal_SyncClockFreq(&MCU_FreqResult);
			SyncClockFreq_Judge(MCU_FreqResult, TE_Sync_Clock_Freq);			
		}
	}
	//1000ms任务
	if(LED_Blink_Enable == 0x01)
	{
		TimeCnt_1000ms++;
		if(TimeCnt_1000ms >= 1000)
		{
				TimeCnt_1000ms = 0;
			//更新ADC转换结果
	//		_Task_ADC_Update();
			HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_9);			
		}
	}
	else
	{
		HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9,GPIO_PIN_SET);
	}
	
	//60s任务
	TimeCnt_60000ms++;
	if(TimeCnt_60000ms >= 60000)
	{
	  TimeCnt_60000ms = 0;
		//运行时间记录
		PBU_RunLog.RunTime++;
	}
	
	MC_error_cnt++;
	if(MC_error_cnt >= 3000)
	{
		MC_error_cnt=0;
		MC_ErrorCode.Code  = 0;
	}
}


//PBU运行模式处理函数
void PBU_RunMode_Process(PBU_RunMode_t RunMode)
{	
	switch(RunMode)
	{
		case PBU_RunMode_MC_AssisitCtrl:
		{
		    //助力模式控制
			switch(PBU_AssitMode_Status.PBU_AssistMode_Flag)
			{
			  case PBU_AssistMode_Flag_WalkSby://预推行模式
				{
					if((*(Key_Up.ADC_result)<1000)&&(*(Key_Walk.ADC_result)>3000)&&(*(Key_Down.ADC_result)>3000))	
					{
						PBU_AssitMode_Status.PBU_AssistMode_Flag = PBU_AssistMode_Flag_Walk;
						ControlCode.GearSt = 0x22;
						PBU_AssitMode_Status.PBU_WalkSbyProcess.HMI_ACK_Flag = TRUE;
					}
					else
					{
//						ControlCode.GearSt = 0x00;
						if(TimeCntDiff_5ms(PBU_AssitMode_Status.WalkDelayTimeCnt) > 2000) //超时2000 * 500 = 10s自动退出Walk等待
						{
							ControlCode.GearSt = PBU_AssitMode_Status.GearStBak_Walk;
							if(PBU_AssitMode_Status.IsSmartEtrWalk_Flag == TRUE)
							{
								PBU_AssitMode_Status.PBU_AssistMode_Flag = PBU_AssistMode_Flag_Smart;
								PBU_AssitMode_Status.IsSmartEtrWalk_Flag = FALSE;
							}
							else
							{
								PBU_AssitMode_Status.PBU_AssistMode_Flag = PBU_AssistMode_Flag_Gear;
							}
							PBU_AssitMode_Status.PBU_WalkSbyProcess.DelayTimeCnt = SysTime_5ms;
							PBU_AssitMode_Status.PBU_WalkSbyProcess.HMI_ACK_Flag = FALSE;
						}
					}
					break;
				}
				case PBU_AssistMode_Flag_Gear://助力模式
				{
					ControlCode.GearSt = PBU_AssitMode_Status.GearStBak_Smart;
					break;
				}
				case PBU_AssistMode_Flag_Walk://推行模式
				{
					if((*(Key_Up.ADC_result)>3000)||((ADC_Result[4]+ADC_Result[2]+ADC_Result[5])<5000))//zsm  防止推行过程中，有两个键同时按下，还继续推行
					{
					  ControlCode.GearSt = PBU_AssitMode_Status.GearStBak_Walk;
						PBU_AssitMode_Status.PBU_AssistMode_Flag = PBU_AssistMode_Flag_WalkSby;
						PBU_AssitMode_Status.WalkDelayTimeCnt = SysTime_5ms;
						PBU_AssitMode_Status.PBU_WalkSbyProcess.HMI_ACK_Flag = FALSE;
						PBU_AssitMode_Status.PBU_WalkSbyProcess.SendCodeTimeCnt_WalkSby = 0;
					}
					break;
				}
				case PBU_AssistMode_Flag_Smart://智能模式
				{
				  ControlCode.GearSt = 0x33;
					break;
				}
				default:break;
			}
			
			//发送预推行模式指令
			if(PBU_AssitMode_Status.PBU_WalkSbyProcess.HMI_ACK_Flag == FALSE)
			{
				if(TimeCntDiff_5ms(PBU_AssitMode_Status.PBU_WalkSbyProcess.SendCodeTimeCnt_WalkSby) > 40) // 超时40 * 5 = 200ms
				{
					if(PBU_AssitMode_Status.PBU_AssistMode_Flag == PBU_AssistMode_Flag_WalkSby)
					{
					    SendData(ID_PBU_TO_HMI, MODE_WRITE, 0x7304, (uint8_t*)"STAR");
					}
					else
					{
					    SendData(ID_PBU_TO_HMI, MODE_WRITE, 0x7304, (uint8_t*)"STOP");
					}
					PBU_AssitMode_Status.PBU_WalkSbyProcess.SendCodeTimeCnt_WalkSby = SysTime_5ms;
				}
				if(TimeCntDiff_5ms(PBU_AssitMode_Status.PBU_WalkSbyProcess.DelayTimeCnt) > 400)//超时400 * 5 = 2s
				{
				  PBU_AssitMode_Status.PBU_WalkSbyProcess.DelayTimeCnt = SysTime_5ms;
					PBU_AssitMode_Status.PBU_WalkSbyProcess.HMI_ACK_Flag = TRUE;
				}
			}
      else
		  {
			    PBU_AssitMode_Status.PBU_WalkSbyProcess.SendCodeTimeCnt_WalkSby = SysTime_5ms;
		  }		
			//发送控制指令
			if(MC_ErrorCode.Code != (uint32_t)0)//存在故障码时，关闭助力
			{
			  ControlCode.GearSt = 0;
				PBU_AssitMode_Status.GearStBak_Smart = 0;
			}			
			if(TimeCntDiff_5ms(PBU_AssitMode_Status.SendCodeTimeCnt_Ctl) >= 10)//超时10 * 5 = 50ms
			{
			  static uint8_t i = 0;
				if(i == 0)
				{
				   i = 1;	
					if(PBU_AssitMode_Status.PBU_AssistMode_Flag==PBU_AssistMode_Flag_WalkSby)
					{
						ControlCode_MC_WalkSby.GearSt=0;
						ControlCode_MC_WalkSby.LightSwitch=ControlCode.LightSwitch;
						SendData(ID_PBU_TO_MC, 0x0C, 0x3002, (uint8_t*)(&(ControlCode_MC_WalkSby.GearSt)));
					}	
					else
					SendData(ID_PBU_TO_MC, 0x0C, 0x3002, (uint8_t*)(&(ControlCode.GearSt)));
				}
				
				else if(i == 1)
				{
				  i = 2;
					SendData(ID_PBU_TO_BMS, 0x11, 0x5000,(uint8_t*)NULL);
				}
								
				else if(i == 2)
				{
				  i = 0;
					SendData(ID_PBU_TO_HMI, 0x0C, 0x7402,(uint8_t*)(&(ControlCode.GearSt)));
				}
				PBU_AssitMode_Status.SendCodeTimeCnt_Ctl = SysTime_5ms;
			}
			
			if((PowerOn_flag==1)&&(PBU_AssitMode_Status.PBU_AssistMode_Flag!=PBU_AssistMode_Flag_WalkSby))
			
			{			
				if(TimeCntDiff_5ms(MC_Online_TimeCnt) >=1000)
				{
					MC_Online_Flag = 0;
					PBU_commErrorCode.ERROR_Bit.Communication_MC_Fault =1;			
				}
        if(MC_Online_Flag == 1)
			  {
				  PBU_commErrorCode.ERROR_Bit.Communication_MC_Fault = 0;
				  PBU_ErrorCode.ERROR_Bit.Communication_MC_Fault = 0;
			  }
			}
			
			if(PowerOn_flag==1)
			{			
				if(TimeCntDiff_5ms(BMS_Online_TimeCnt) >=1000)
				{
					BMS_Online_Flag = 0;
		//		PBU_commErrorCode.ERROR_Bit.Communication_Fault =1;		
				}
			}
								
			break;
		}
		case PBU_RunMode_CDL_KeyTest:
		{
		    static uint8_t SendCnt = 0;
			//退出按键测试模式前，100ms发送一次按键状态
			if( (PBU_Test_Process.KeyTest_Status.Status&0x3F) != 0x00)
			{
				if(TimeCntDiff_5ms(PBU_Test_Process.SendCodeTimeCnt) >= 40)//超时40 * 5 = 200ms
				{
					SendData(ID_PBU_TO_CDL, MODE_REPORT, 0x9101, &(PBU_Test_Process.KeyTest_Status.Status));
					SendCnt++;
					if(SendCnt >= 5)
					{
						SendCnt = 0;
						PBU_Test_Process.KeyTest_Status.Status = 0x00;
					}
					PBU_Test_Process.SendCodeTimeCnt = SysTime_5ms;
				}
			}
			else
			{
					PBU_Test_Process.SendCodeTimeCnt = SysTime_5ms;
			}
			MC_Online_TimeCnt=SysTime_5ms;
			BMS_Online_TimeCnt=SysTime_5ms;
			break;
		}
		case PBU_RunMode_PowerOff:
		{
			/* Send shutdown command to AUX_MCU */
//    Shutdown_AUX();	
			LED_INIT();
			
			//关机前,发送指令关灯,避免下次开机时灯会闪亮一下
			static uint8_t LightOffCommandCount=0;
			if(LightOffCommandCount==0)
			{
				LightOffCommandCount=1;
				ControlCode_MC_WalkSby.GearSt = 0;
				ControlCode_MC_WalkSby.LightSwitch = 0xF0;
				SendData(ID_PBU_TO_MC, 0x0C, 0x3002, (uint8_t*)(&(ControlCode_MC_WalkSby.GearSt)));
				HAL_Delay(20);
				SendData(ID_PBU_TO_MC, 0x0C, 0x3002, (uint8_t*)(&(ControlCode_MC_WalkSby.GearSt)));
				HAL_Delay(20);
			}
			PowerOn_flag=0;			
		  //关机前发送SHUTDOWN指令，收到所有设备关机就绪信号，或超时2s关机
			if((PBU_PowerOff_Process.Ready_Status.Status & 0x01) != 0x01)//未收到所有设备的关机就绪信号
			{
				if(TimeCntDiff_5ms(PBU_PowerOff_Process.SendCodeTimeCnt) >= 20)//超时20 * 5ms = 100ms
				{
				  SendData(ID_PBU_BC, MODE_REPORT, 0x1008, (uint8_t*)"SHUTDOWN");
					PBU_PowerOff_Process.SendCodeTimeCnt = SysTime_5ms;
				}
			}
			else
			{
			  //关机前处理
				//...
				SYS_POWER_OFF();
				SendMotorDisableToTE();
				LED_INIT_ALL();
				do
				{	
					HAL_IWDG_Refresh(&hiwdg1);
				}while(*(Key_On_Off.ADC_result)<3000);
				__set_FAULTMASK(1);//关闭所有中断
				HAL_Delay(200);
				HAL_NVIC_SystemReset();
			}
			//超时判断
			if(TimeCntDiff_5ms(PBU_PowerOff_Process.DelayTimeCnt) >= 200)//超200 * 5ms = 1s
			{
			  //关机前处理
				//...  
				SYS_POWER_OFF();
				SendMotorDisableToTE();
				LED_INIT_ALL();
				do
				{	
					HAL_IWDG_Refresh(&hiwdg1);
				}while(*(Key_On_Off.ADC_result)<3000);
				__set_FAULTMASK(1);//关闭所有中断
				HAL_Delay(200);				
				HAL_NVIC_SystemReset();
			 }
			MC_Online_TimeCnt=SysTime_5ms;
			BMS_Online_TimeCnt=SysTime_5ms;
			break;
		}
		case PBU_RunMode_Updating:
		{
			MC_Online_TimeCnt=SysTime_5ms;
			BMS_Online_TimeCnt=SysTime_5ms;
			ControlCode.GearSt = 0;
			PBU_AssitMode_Status.GearStBak_Smart = 0;
    	PBU_AssitMode_Status.GearStBak_Walk = 0;
			break;
		}
		
		default:break;
	}
}

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

//PBU开机判断，开关机按键弹起或超时5s后，再次检测开关机按键状态
void PBU_PowerOn_Judge(void)
{
  KeyScanCode_Struct_t KeyState;
	
	switch(PBU_PowerOn_Process.PowerKeyStatus)
	{
    //初始状态	 
		case 0:
		{
			KeyState = KeyScan();
			if((KeyState.Code & 0x3F) == 0x01)
			{
				PBU_PowerOn_Process.PowerOnOKCnt++;
				if( PBU_PowerOn_Process.PowerOnOKCnt >= 10 )
				{
					LED_Blink_Enable = 0x01;
  				SYS_POWER_ON();
					SendMotorEnableToTE();
					HAL_Delay(50);
					SendMotorEnableToTE();
					HAL_Delay(50);
					SendMotorEnableToTE();
					HAL_Delay(50);
					SendMotorEnableToTE();						
					PBU_PowerOn_Process.PowerKeyStatus = 1;
				}
			}
			else
			{
				PBU_PowerOn_Process.PowerOnOKCnt=0;
			}
			break;
		}
		//按下中
		case 1:
		{
			if(*(Key_On_Off.ADC_result)>3000)
	    {
		    PBU_PowerOn_Process.PowerKeyStatus = 2;
	  	}
			break;
		}
		//弹起
		case 2:
		{
		
			break;
		}
		default:break;
	}
}

//发送配置参数给到MC
void SendCfgToMC(void)
{
  uint8_t SendBuf[8] = {0};
	
	//复制参数
	SendBuf[0] = PBU_ConfigParam.GearsNum;
  SendBuf[1] = PBU_ConfigParam.NoHMI_Flag;
	
	//开始发送数据，收到ACK前，100ms发送一次，超时2s
	PBU_MC_Cfg.DelayTimeCnt = SysTime_5ms;
	PBU_MC_Cfg.SendCodeTimeCnt = SysTime_5ms;
	do	
	{
	  if(TimeCntDiff_5ms(PBU_MC_Cfg.SendCodeTimeCnt) > 20) // 超时20 * 5 = 100ms
		{
		    SendData(ID_PBU_TO_MC, MODE_WRITE, 0x3208, SendBuf);
				PBU_MC_Cfg.SendCodeTimeCnt = SysTime_5ms;
		}
		 CAN_RxData_Process(&CAN_RxBuf_Struct_MC, 500);
	}while((PBU_MC_Cfg.MC_ACK_Flag == FALSE) && (TimeCntDiff_5ms(PBU_MC_Cfg.DelayTimeCnt) <= 400));//超时2s
	PBU_MC_Cfg.MC_ACK_Flag = TRUE;
}

//发送故障码
void PBU_Error_Process(void)
{
  static uint32_t SendCodeTimeCnt = 0;

	if(PBU_RunMode != PBU_RunMode_Updating)
	{		
		PBU_ErrorCode.Code = PBU_hardwareErrorCode.Code | PBU_commErrorCode.Code;
		PBU_Error_senddata=PBU_ErrorCode.Code;
		if(PBU_Error_senddata != 0)
		{
			if(PBU_ErrorFlag == FALSE)
			{
				SendCodeTimeCnt = SysTime_5ms;
				PBU_ErrorFlag = TRUE;
			}
			if(TimeCntDiff_5ms(SendCodeTimeCnt) > 100) // 超时100 * 5 = 500ms
			{
				SendData(ID_PBU_BC, MODE_REPORT, 0x1504, (uint8_t*)&PBU_Error_senddata);
				SendCodeTimeCnt = SysTime_5ms;
				PBU_Error_senddata = 0;
			}
		}
		else
		{
				PBU_ErrorFlag = FALSE;
		}
	}
}

//自动关机处理
void AutoPowerOff_Process(void)
{
  static uint32_t DelayTimeCnt = 0;
	static TrueOrFalse_Flag_Struct_t IsFirstEnterFlag = TRUE;
	static KeyScanCode_Struct_t KeySate;
	KeyScanCode_Struct_t KeySate_Temp;
		
	if(IsFirstEnterFlag == TRUE)
	{
	  DelayTimeCnt = SysTime_5ms;
		KeySate = KeyScan();
		IsFirstEnterFlag = FALSE;
	}
	
	KeySate_Temp = KeyScan();
	if((MC_RunInfo.BikeSpeed != 0) ||                 //无车速
		 (MC_RunInfo.Cadence != 0) ||                   //无踏频
	   (MC_RunInfo.MotorSpeed != 0)||                 //电机无转速
	   (MC_RunInfo.Torque > 5) ||                     //无力矩
	   (KeySate.Code != KeySate_Temp.Code) || 
		 (PBU_RunMode == PBU_RunMode_CDL_KeyTest)	)           //无按键触发
	{
	  DelayTimeCnt = SysTime_5ms;
	}
	else
	{
	  if((TimeCntDiff_5ms(DelayTimeCnt) > 60000)) // 超时60000 * 5ms = 300s
		{
			DelayTimeCnt = SysTime_5ms;
		  PBU_RunMode = PBU_RunMode_PowerOff;
			PBU_PowerOff_Process.DelayTimeCnt = SysTime_5ms;
			PBU_PowerOff_Process.SendCodeTimeCnt = 0;			
		}
	}
	KeySate = KeySate_Temp;
}

/* Functional safety key processing */
void FSK_Process(void)
{
	static uint8_t TE_Online_DetectIniFlag=0;
	if(HAL_GetTick() < 5000) //前5s屏蔽与TE检测有关的错误,5s后TE稳定后开始检测故障
	{
		PBU_TE_ErrorCode.Code=0;
		TE_Online_DetectIniFlag = 0;
	}
	else //开始TE故障检测
	{
		if(PBU_TE_Status == UPDATE_ING)
		{
			PBU_TE_FaultDetectFlag= FALSE;
			TE_Online_DetectIniFlag = 0;
		}
		else
		{
			PBU_TE_FaultDetectFlag= TRUE;
			Scan_Key();
			
			if( TE_Online_DetectIniFlag == 0 ) 
			{
				TE_Online_DetectIniFlag = 1;
				TE_Online_TimeCnt = SysTime_5ms;
			}
			if(TimeCntDiff_5ms(TE_Online_TimeCnt) >=800)
			{									
				TE_Online_Flag = 0;
				PBU_TE_ErrorCode.ERROR_Bit.Hardware_Fault =1;			
			}	
		}	
	}
	Error_Key_Process();  //检测按键粘连10s
}


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