motor_ctl-2/User/Src/can_process.c

#include "can_process.h"
#include "uart_process.h"
#include "motor_control.h"
#include "crc_cal.h"
#include "var.h"
#include "eeprom_24c02.h"
#include "eeprom_flash.h"
#include "tasks.h"
#include "ctf_process.h"
#include "log_save.h"

/**********局部函数定义**********/
uint8_t cd_ReadChar(CAN_Buf_TypeDef * ptCANRx, uint8_t ucNum)	 
{	
	uint8_t ucData;
	uint16_t  i;
	i = ucNum;
	if ((*ptCANRx).ucBufCnt >= ucNum)
	 {
		i += (*ptCANRx).ucBufRdInde;
		if (i >= (*ptCANRx).ucBufSize)
		{	
			i -=((*ptCANRx).ucBufSize);
		}
	 }
	else
	 {
	  i=0;
	 }
	ucData = *((*ptCANRx).pcBufAddr + i);
	return ucData;
}

void cd_DelChar(CAN_Buf_TypeDef * ptCANRx, uint8_t ucNum)	 
{	
	uint16_t i;
	if ((*ptCANRx).ucBufCnt >= ucNum)	
	{	
		__HAL_CAN_DISABLE_IT(&hcan, CAN_IT_FMP0);//关接收中断
		(*ptCANRx).ucBufCnt -= ucNum;	
		__HAL_CAN_ENABLE_IT(&hcan, CAN_IT_FMP0);//开接收中断
		i = ucNum;
		i += (*ptCANRx).ucBufRdInde;
		if (i >= (*ptCANRx).ucBufSize)
		{
		  i -= (*ptCANRx).ucBufSize;
		}
		(*ptCANRx).ucBufRdInde = i;
	}
	else
	{  
		__HAL_CAN_DISABLE_IT(&hcan, CAN_IT_FMP0);//关接收中断
   	    i = (*ptCANRx).ucBufCnt;
        (*ptCANRx).ucBufCnt = 0;
		__HAL_CAN_ENABLE_IT(&hcan, CAN_IT_FMP0);//开接收中断
        i += (*ptCANRx).ucBufRdInde;
		if (i >= (*ptCANRx).ucBufSize)
		{
		  i -= (*ptCANRx).ucBufSize;
		}
		(*ptCANRx).ucBufRdInde = i;
	 }
}

//数据解析处理
void DataProcess(uint16_t ID, uint8_t Mode, uint16_t Cmd, uint8_t* Data)
{
  uint8_t DataLength;
	
	DataLength = (uint8_t)(Cmd &0x00FF);
	
	switch(ID)
	{		
		//处理BMS发送的指令
		case ID_BMS_BC: case ID_BMS_TO_MC:
		{
			switch(Cmd)			
			{
		  	//BMS广播的指令
				case 0x1010://BMS运行信息
				{
					//更新电池运行信息
					memcpy(&BMS_RunInfo.Voltage, Data, DataLength); 
					MC_RunInfo.SOC = BMS_RunInfo.SOC;
					//电池通信正常标志置位，用于续航计算
					RemainDis.IsBMS_ComOK_Flag = TRUE;              
					RemainDis.BMS_Com_DelayTimeCnt = HAL_GetTick();
					//BMS通信正常标志置位
			    IsComOK_BMS.IsOK_Flag = TRUE;
			    IsComOK_BMS.OK_TrigTime = HAL_GetTick();
					break;
				}
				case 0x1308://关机指令
				{					
					PowerOff_Process(FALSE);
					break;
				}
				case 0x1410://电池设计信息
				{
					memcpy(&BMS_DesignInfo.Capacity, Data, DataLength);
					break;
				}
				case 0x160C://电池物理ID
				{
				  memcpy(BMS_CheckInfo.MAC_ID, Data, DataLength);
					break;
				}
				case 0x170C://电池存储的校验码
				{
				  memcpy(BMS_CheckInfo.CheckCode, Data, DataLength);
					break;
				}
				//BMS发送给MC的指令
				case 0x3005://电池在线检测反馈
				{
				  if(strncmp("READY", (char*)Data, DataLength) == 0)
					{
					  DeviceOnLine_Status.Status_Bit.BMS_OffLine = 0;
					}
				  break;
				}
				default:break;
			}
			
			break;
		}
		//处理PBU发送的指令
		case ID_PBU_BC: case ID_PBU_TO_MC:
		{	  		
			switch(Cmd)
			{
				//PBU广播的指令
        case 0x1008://PBU关机指令
				{
					PowerOff_Process(FALSE);
					break;
				}
				case 0x120C://PBU物理ID
				{
				  memcpy(PBU_CheckInfo.MAC_ID, Data, DataLength);
					break;
				}
				case 0x130C://PBU存储的校验码
				{
					memcpy(PBU_CheckInfo.CheckCode, Data, DataLength);
					break;
				}
				
				#if 1  // PBU/OBC发送给MC的指令
				case 0x3002://控制电机指令
				{
				  if(MC_WorkMode == MC_WorkMode_Run)
					{
					  memcpy(&MC_ControlCode.GearSt, Data, DataLength);
					  Update_MC_ControlCode_Back();
					}			
		      MC_RunInfo.GearSt = MC_ControlCode.GearSt;//当前助力档位更新
					MC_RunInfo.LightSwitch = MC_ControlCode.LightSwitch;
					SendData(ID_MC_BC, MODE_REPORT, 0x1020, (uint8_t*)&MC_RunInfo.BikeSpeed);
					//PBU通信正常标志置位
			    IsComOK_PBU.IsOK_Flag = TRUE;
			    IsComOK_PBU.OK_TrigTime = HAL_GetTick();
					break;
				}
				case 0x3105://PBU在线检测反馈
				{
				  if(strncmp("READY", (char*)Data, DataLength) == 0)
					{
					  DeviceOnLine_Status.Status_Bit.PBU_OffLine = 0;
					}
					break;
				}
				case 0x3208://PBU控制参数配置
				{
				  memcpy(&PBU_ConfigParam.GearsNum, Data, DataLength);
					SendData(ID_MC_TO_PBU, MODE_REPORT, 0x5303, (uint8_t*)"ACK");
					break;
				}
				case 0x3300://OBC查询用户参数
				{
				  ReadDataFromEEPROM_Flash(EEPROM_FLASH_ADDR_CONFIG_PARAM1, Data, sizeof(MC_ConfigParam1_Struct_t));
					memcpy((uint8_t*)&MC_ConfigParam1.GasCtrlMode_Flag, Data, sizeof(MC_ConfigParam1_Struct_t));
					Data[0] = MC_ConfigParam1.WheelSize;   //轮胎默认周长
					Data[1] = MC_ConfigParam1.StarModel;   //启动模式
					Data[2] = MC_ConfigParam1.SpeedLimit;  //限速值
					Data[3] = MC_ConfigParam1.WheelSizeAdj;//轮胎微调值
					SendData(ID_MC_TO_PBU, MODE_REPORT, 0x5408, Data);
					break;
				}
				case 0x3408://OBC设置用户参数
				{
				  MC_ConfigParam1.WheelSizeAdj = (int8_t)Data[0];
					if(MC_ConfigParam1.WheelSizeAdj > 10)
					{
						MC_ConfigParam1.WheelSizeAdj = 10;
					}
					if(MC_ConfigParam1.WheelSizeAdj < -10)
					{
						MC_ConfigParam1.WheelSizeAdj = -10;
					}
					MC_ConfigParam1.StarModel = (MC_StarMode_Struct_t)Data[1];
					IsFlashSaveDataUpdate = TRUE;
					SendData(ID_MC_TO_PBU, MODE_REPORT, 0x5303, (uint8_t*)"ACK");
					break;
				}
				case 0x3500://OBC查询骑行历史
				{
				  SendData(ID_MC_BC, MODE_REPORT, 0x1510, (uint8_t*)&MC_RideLog.ODO_Km);
					break;
				}
				case 0x3605://OBC清除TRIP信息
				{
			  	if(strncmp("CLEAR", (char*)Data, DataLength) == 0)
					{
					  MC_RideLog.TRIP_Km = 0;
						MC_RideLog.TRIP_Time = 0;
						SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RIDE_LOG, sizeof(MC_RideLog_Struct_t), (uint8_t*)&MC_RideLog.ODO_Km);
						SendData(ID_MC_TO_PBU, MODE_REPORT, 0x5303, (uint8_t*)"ACK");
						MC_RunInfo.Ride_Km = 0;
						MC_RunInfo.Ride_Time = 0;
					}
					break;
				}
				#else //ECU的指令
				case 0x3300://ECU查询用户参数
				{
				  GetParamFromEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_CONFIG_PARAM1, sizeof(MC_ConfigParam1), (uint8_t*)&MC_ConfigParam1.GasCtrlMode_Flag);
					Data[0] = MC_ConfigParam1.WheelSize;   //轮胎默认周长
					Data[1] = MC_ConfigParam1.SpeedLimit;  //限速值
					Data[2] = 0x18;                        //低压保护阈值 31000mV
					Data[3] = 0x79;
					SendData(ID_MC_TO_PBU, MODE_REPORT, 0x5410, Data);
					break;
				}
				case 0x3708://ECU控制指令
				{
				if(MC_WorkMode == MC_WorkMode_Run)
					{
					  memcpy(&MC_ControlCode.GearSt, Data, 2);
					  Update_MC_ControlCode_Back();
					}			
		      MC_RunInfo.GearSt = MC_ControlCode.GearSt;//当前助力档位更新
					MC_RunInfo.LightSwitch = MC_ControlCode.LightSwitch;
					SendData(ID_MC_BC, MODE_REPORT, 0x1020, (uint8_t*)&MC_RunInfo.BikeSpeed);
					//PBU通信正常标志置位
			    IsComOK_PBU.IsOK_Flag = TRUE;
			    IsComOK_PBU.OK_TrigTime = HAL_GetTick();
					break;
				}
				case 0x3810://ECU设置用户参数
				{
			  	MC_ConfigParam1.WheelSize = Data[0];
					if(MC_ConfigParam1.WheelSize > 250)
					{
					  MC_ConfigParam1.WheelSize = 250;
					}
					if(MC_ConfigParam1.WheelSize < 120)
					{
					  MC_ConfigParam1.WheelSize = 120;
					}
					MC_ConfigParam1.SpeedLimit = Data[1];
					if(MC_ConfigParam1.SpeedLimit > 99)
					{
					  MC_ConfigParam1.SpeedLimit = 99;
					}
					if(MC_ConfigParam1.SpeedLimit < 5)
					{
					  MC_ConfigParam1.SpeedLimit = 5;
					}
					//Data[2]和Data[3]低压保护值暂不处理
					SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_CONFIG_PARAM1, sizeof(MC_ConfigParam1), (uint8_t*)&MC_ConfigParam1.GasCtrlMode_Flag);
					SendData(ID_MC_TO_PBU, MODE_REPORT, 0x5303, (uint8_t*)"ACK");
					break;
				}
				#endif
				
				case 0x3900://OBC/ECU查询版本信息
				{
				  ReadDataFromEEPROM_Flash(EEPROM_FLASH_ADDR_MODE, (uint8_t*)MC_VerInfo.Mode, 16);
					ReadDataFromEEPROM_Flash(EEPROM_FLASH_ADDR_SN, (uint8_t*)MC_VerInfo.SN_Num, 16);
					SendData(ID_MC_BC, MODE_REPORT, 0x1240, (uint8_t*)MC_VerInfo.Mode);
					SendData(ID_MC_BC, MODE_REPORT, 0x1720, (uint8_t*)Firmware_Special);
					break;
				}
				
				default:break;
			}
			break;
		}
		//处理HMI发送的指令
		case ID_HMI_BC: case ID_HMI_TO_MC:
		{
		  switch(Cmd)
			{
			  //HMI广播的指令
				case 0x110C://HMI物理ID
				{
				  memcpy(HMI_CheckInfo.MAC_ID, Data, DataLength);
					break;
				}
				case 0x120C://HMI存储的校验码
				{
				  memcpy(HMI_CheckInfo.CheckCode, Data, DataLength);
					break;
				}
				case 0x1508://HMI运行信息
				{
				  //HMI通信正常标志置位
			    IsComOK_HMI.IsOK_Flag = TRUE;
			    IsComOK_HMI.OK_TrigTime = HAL_GetTick();
					break;
				}
				//HMI发送MC的指令
				case 0x3000://查询电机版本信息
				{
				  ReadDataFromEEPROM_Flash(EEPROM_FLASH_ADDR_MODE, (uint8_t*)MC_VerInfo.Mode, 16);
					ReadDataFromEEPROM_Flash(EEPROM_FLASH_ADDR_SN, (uint8_t*)MC_VerInfo.SN_Num, 16);
					SendData(ID_MC_BC, MODE_REPORT, 0x1240, (uint8_t*)MC_VerInfo.Mode);
					SendData(ID_MC_BC, MODE_REPORT, 0x1720, (uint8_t*)Firmware_Special);
					break;
				}
				case 0x3100://查询电机配置参数
				{
				  ReadDataFromEEPROM_Flash(EEPROM_FLASH_ADDR_CONFIG_PARAM1, Data, sizeof(MC_ConfigParam1_Struct_t));
					memcpy((uint8_t*)&MC_ConfigParam1.GasCtrlMode_Flag, Data, sizeof(MC_ConfigParam1_Struct_t));
					Data[0] = MC_ConfigParam1.WheelSize;   //轮胎默认周长
					Data[1] = MC_ConfigParam1.StarModel;   //启动模式
					Data[2] = MC_ConfigParam1.SpeedLimit;  //限速值
					Data[3] = MC_ConfigParam1.WheelSizeAdj;//轮胎微调值
					SendData(ID_MC_TO_HMI, MODE_REPORT, 0x7308, Data);
					break;
				}
				case 0x3208://设置电机配置参数
				{
					MC_ConfigParam1.WheelSizeAdj = (int8_t)Data[0];
					if(MC_ConfigParam1.WheelSizeAdj > 10)
					{
						MC_ConfigParam1.WheelSizeAdj = 10;
					}
					if(MC_ConfigParam1.WheelSizeAdj < -10)
					{
						MC_ConfigParam1.WheelSizeAdj = -10;
					}
					MC_ConfigParam1.StarModel = (MC_StarMode_Struct_t)Data[1];
					IsFlashSaveDataUpdate = TRUE;
					SendData(ID_MC_TO_HMI, MODE_REPORT, 0x7403, (uint8_t*)"ACK");
					break;
				}
				case 0x3305://HMI在线检测反馈
				{
				  if(strncmp("READY", (char*)Data, DataLength) == 0)
					{
					  DeviceOnLine_Status.Status_Bit.HMI_OffLine = 0;
					}
					break;
				}
			  case 0x3400://查询电机骑行历史信息
				{
					SendData(ID_MC_BC, MODE_REPORT, 0x1510, (uint8_t*)&MC_RideLog.ODO_Km);
					break;
				}
				case 0x3505://清除TRIP信息
				{
				  if(strncmp("CLEAR", (char*)Data, DataLength) == 0)
					{
					  MC_RideLog.TRIP_Km = 0;
						MC_RideLog.TRIP_Time = 0;
						SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RIDE_LOG, sizeof(MC_RideLog_Struct_t), (uint8_t*)&MC_RideLog.ODO_Km);
						SendData(ID_MC_TO_HMI, MODE_REPORT, 0x7403, (uint8_t*)"ACK");
						MC_RunInfo.Ride_Km = 0;
						MC_RunInfo.Ride_Time = 0;
					}
				}
				default:break;
			}
			break;
		}
		//处理CDL发送的指令
		case ID_CDL_BC: case ID_CDL_TO_MC:
		{
			switch(Cmd)
			{
			  case 0x1000://查询校验密钥
				{
				  GetParamFromEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_SECRET_KEY, sizeof(Secret_Key), Secret_Key);
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA408, Secret_Key);
					break;
				}
				case 0x1108://写入校验密钥
				{
				  memcpy(Secret_Key, Data, DataLength);
					SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_SECRET_KEY, sizeof(Secret_Key), Secret_Key);
					SendData(ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
					//写入密钥后时，重新对电机授权码计算和存储
					Ctf_CalAndSave();
					break;
				}
				case 0x1200://查询电机版本信息
				{
				  ReadDataFromEEPROM_Flash(EEPROM_FLASH_ADDR_MODE, (uint8_t*)MC_VerInfo.Mode, 16);
					ReadDataFromEEPROM_Flash(EEPROM_FLASH_ADDR_SN, (uint8_t*)MC_VerInfo.SN_Num, 16);
					SendData(ID_MC_BC, MODE_REPORT, 0x1240, (uint8_t*)MC_VerInfo.Mode);
					SendData(ID_MC_BC, MODE_REPORT, 0x1720, (uint8_t*)Firmware_Special);
					break;
				}
				case 0x1300://查询自定义字符串1
				{
				  ReadDataFromEEPROM_Flash(EEPROM_FLASH_ADDR_USER_INFO1, UserString1, 16);
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA610, UserString1);
					break;
				}
				case 0x1410://写入自定义字符串1
				{
				  memcpy(UserString1, Data, DataLength);
					IsFlashSaveDataUpdate = TRUE;
					SendData(ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
					break;
				}
				case 0x1500://查询自定义字符串2
				{
				  ReadDataFromEEPROM_Flash(EEPROM_FLASH_ADDR_USER_INFO2, UserString2, 16);
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA710, UserString2);
					break;
				}
				case 0x1610://写入自定义字符串2
				{
				  memcpy(UserString2, Data, DataLength);
					IsFlashSaveDataUpdate = TRUE;
					SendData(ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
					break;
				}
				case 0x1700://查询自定义字符串3
				{
				  ReadDataFromEEPROM_Flash(EEPROM_FLASH_ADDR_USER_INFO3, UserString3, 16);
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA810, UserString3);
					break;
				}
				case 0x1810://写入自定义字符串3
				{
				  memcpy(UserString3, Data, DataLength);
					IsFlashSaveDataUpdate = TRUE;
					SendData(ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
					break;
				}
				case 0x1901://写入电机工作模式
				{
				  MC_WorkMode = (MC_WorkMode_Struct_t)*Data;
					MC_WorkMode_Back = (MC_WorkMode_Struct_t)~MC_WorkMode;
					//配置模式时，清除设备校验失败故障码
					if(MC_WorkMode == MC_WorkMode_Config)
					{
					  MC_ErrorCode.ERROR_Bit.Fault_BMS_Check = 0;
						MC_ErrorCode.ERROR_Bit.Fault_PBU_Check = 0;
						MC_ErrorCode.ERROR_Bit.Fault_HMI_Check = 0;
					}
					break;
				}
				case 0x1A00://查询电机控制参数1
				{
				  ReadDataFromEEPROM_Flash(EEPROM_FLASH_ADDR_CONFIG_PARAM1, Data, sizeof(MC_ConfigParam1_Struct_t));
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA020, Data);
					break;
				}
				case 0x1B20://写入电机控制参数1
				{
				  memcpy((uint8_t*)&MC_ConfigParam1.GasCtrlMode_Flag, Data, DataLength);
					IsFlashSaveDataUpdate = TRUE;
					//助力参数初始化
	        UpdateGearParam(MC_ConfigParam1.SerialNum);
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
					break;
				}
				case 0x1C00://查询马达参数
				{
				  ReadDataFromEEPROM_Flash(EEPROM_FLASH_ADDR_MOTOR_PARAM, Data, sizeof(MC_MotorParam_Struct_t));
//					MC_MotorParam.Coil_Ld = PID_IMax.hKp_Gain;
//					MC_MotorParam.Coil_Lq = PID_IMax.hKp_Divisor;				
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA110, Data);
					break;
				}
				case 0x1D10://写入马达参数
				{
				  memcpy((uint8_t*)&MC_MotorParam.Rate_Power, Data, DataLength);
					IsFlashSaveDataUpdate = TRUE;
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
//					PID_IMax.hKp_Gain    = MC_MotorParam.Coil_Ld;
//					PID_IMax.hKp_Divisor = MC_MotorParam.Coil_Lq;
					break;
				}
				case 0x1E00://查询电机历史信息
				{
					//历史信息1
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA230, (uint8_t*)&MC_RunLog1.PowerOnCnt); // 发送历史信息1
					//历史信息2
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xAC10, (uint8_t*)&MC_RunLog2.MCU_FaultCnt); // 发送历史信息2
					break;
				}
				case 0x1F00://查询电机生产信息
				{
				  ReadDataFromEEPROM_Flash(EEPROM_FLASH_ADDR_MAC_INFO, (uint8_t*)MC_MacInfo.Manufacturer, 32);
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA520, (uint8_t*)MC_MacInfo.Manufacturer);
					break;
				}
				case 0x2000://查询力矩传感器零偏数据
				{
				  //...三力矩传感器，不用该命令
					break;
				}
				case 0x2100://查询设备在线结果
				{
				  SendData(ID_MC_BC, MODE_REPORT, 0x1401, &DeviceOnLine_Status.Status);
					break;
				}
				case 0x2210://写入电机Mode
				{
				  memcpy(MC_VerInfo.Mode, Data, DataLength);
					IsFlashSaveDataUpdate = TRUE;
					SendData(ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
					//写入型号时，完成电机授权码计算和存储
					Ctf_CalAndSave();
					break;
				}
				case 0x2310://写入电机SN
				{
				  memcpy(MC_VerInfo.SN_Num, Data, DataLength);
					IsFlashSaveDataUpdate = TRUE;
					SendData(ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
					break;
				}
				case 0x2420://写入电机生产信息
				{
				  memcpy(MC_MacInfo.Manufacturer, Data, DataLength);
					IsFlashSaveDataUpdate = TRUE;
					SendData(ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
					break;
				}
				case 0x2505://复位指令
				{
				  if(strncmp("RESET", (char*)Data, DataLength) == 0)
					{
						SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
						PowerOff_Process(TRUE);
		    	  HAL_Delay(100);
			      __set_FAULTMASK(1);//关闭所有中断
			      HAL_NVIC_SystemReset();
					}
					break;
				}
				case 0x2605://系统清除
				{
				  if(strncmp("CLEAR", (char*)Data, DataLength) == 0)
					{
					  EEPROM_24C02_ClearData(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_FLAG, EEPROM_24C02_ADDR_FLAG + 4, 0xFF);
						EEPROM_Flash_Erase(EEPROM_FLASH_BEGIN_ADDRESS, EEPROM_FLASH_END_ADDRESS);
						EEPROM_Flash_Erase(LOG_ADDRESS_BEGIN, LOG_ADDRESS_END);
						SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
				  	__set_FAULTMASK(1);//关闭所有中断
			      HAL_NVIC_SystemReset();
					}
					break;
				}
				case 0x2708://参数还原
				{
					if(strncmp("RECOVERY", (char*)Data, DataLength) == 0)
					{
					  Var_SetToDefaultParam();
						EEPROM_24C02_ParamReset(&I2C_Handle_EEPROM);
						SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
				  	__set_FAULTMASK(1);//关闭所有中断
			      HAL_NVIC_SystemReset();
					}
					break;
				}
				case 0x2802://控制指令
				{
			 		memcpy(&MC_ControlCode.GearSt, Data, DataLength);
					Update_MC_ControlCode_Back();
					
					//PBU通信正常标志置位，避免上位機測試時認爲PBU失聯而關閉助力
		    	IsComOK_PBU.IsOK_Flag = TRUE;
			    IsComOK_PBU.OK_TrigTime = HAL_GetTick();
					//運行信息助力档位更新
					MC_RunInfo.GearSt = MC_ControlCode.GearSt;//当前助力档位更新
					MC_RunInfo.LightSwitch = MC_ControlCode.LightSwitch;
					SendData(ID_MC_BC, MODE_REPORT, 0x1020, (uint8_t*)&MC_RunInfo.BikeSpeed);
					break;
				}
				case 0x2900://查询力矩传感器校正信息
				{
				  //...三力矩传感器，不用该命令
					break;
				}
				case 0x2A01://写入力矩传感器标定系数
				{
				  //...三力矩传感器，不用该命令
					break;
				}
				case 0x2B02://写入力矩传感器启动值
				{
				  memcpy((uint8_t*)&TorqueSensorStartData, Data, DataLength);
					SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_TORQUE_STARDATA, sizeof(TorqueSensorStartData), (uint8_t*)&TorqueSensorStartData);
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
					break;
				}
				case 0x2C01://设置推行模式最高转速百分比
				{
				  MC_WalkMode_Persent = Data[0];
					break;
				}
        case 0x2D08://读取Flash存储器指定地址数据
				{
				  do
					{
						uint32_t DataLength;
						DataLength = (uint32_t)((Data[4] << 24) + (Data[5] << 16) + (Data[6] << 8) + (Data[7])) - (uint32_t)((Data[0] << 24) + (Data[1] << 16) + (Data[2] << 8) + (Data[3])) + 1;
						memcpy((uint8_t*)(Data + 8), (uint8_t*)((Data[0] << 24) + (Data[1] << 16) + (Data[2] << 8) + (Data[3])), DataLength);
						SendData(ID_MC_TO_CDL, MODE_REPORT, (0xAB08 + DataLength), (uint8_t*)Data);	
					}while(0);
					break;
				}
				case 0x2E00://查询骑行历史信息
				{
					SendData(ID_MC_BC, MODE_REPORT, 0x1510, (uint8_t*)&MC_RideLog.ODO_Km);
					break;
				}
				case 0x2F00://读取姿态传感器数值
				{
				  SendData(ID_MC_BC, MODE_REPORT, 0x1608, (uint8_t*)&MC_AttitudeAngle.Angle_Pitch_Absolute);
					break;
				}
				case 0x3000://查询电机控制参数2
				{
				  ReadDataFromEEPROM_Flash(EEPROM_FLASH_ADDR_CONFIG_PARAM2, Data, sizeof(MC_ConfigParam2_Struct_t));
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xAD20, Data);
					break;
				}
				case 0x3120://写入电机控制参数2
				{
				  memcpy((uint8_t*)&MC_ConfigParam2.ZeroAngle_Pitch, Data, DataLength);
					IsFlashSaveDataUpdate = TRUE;
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
					break;
				}
				case 0x3201://查询力矩传感器零点值
        {
          //Data[0]表示需要读取的传感器序号，相邻两个地址偏差为29
          GetParamFromEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_TORQUE_OFFSET_1 + (29 * (Data[0] - 1)), sizeof(TorqueOffSetData_Struct_t), Data + 1);
          switch(Data[0])
          {
            case 1:
            {
              memcpy((uint8_t*)(Data + 23), (uint16_t*)&TorqueSensor_1_Param.Torque_OffSetData.PresentData, 2);
              break;
            }
            case 2:
            {
              memcpy((uint8_t*)(Data + 23), (uint16_t*)&TorqueSensor_2_Param.Torque_OffSetData.PresentData, 2);
              break;
            }
            case 3:
            {
              memcpy((uint8_t*)(Data + 23), (uint16_t*)&TorqueSensor_3_Param.Torque_OffSetData.PresentData, 2);
              break;
            }
          }
          SendData(ID_MC_TO_CDL, MODE_REPORT, 0xAE1A, Data);
          break;
        }
				case 0x3301://查询力矩传感器标定系数
				{
				  //Data[0]表示需要读取的传感器序号，相邻两个地址偏差为29
					GetParamFromEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_TORQUE_1_CAL_K + (29 * (Data[0] - 1)), sizeof(uint8_t), Data + 1);
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xAF02, Data);
					break;
				}
				case 0x3402://写入力矩传感器标定系数
				{
				  //Data[0]表示需要读取的传感器序号
					if(Data[0] == 1)
					{
					  TorqueSensor_1_Param.Torque_Cal_K = Data[1];
						SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_TORQUE_1_CAL_K, sizeof(TorqueSensor_1_Param.Torque_Cal_K), &TorqueSensor_1_Param.Torque_Cal_K);
					}
					else if(Data[0] == 2)
					{
					  TorqueSensor_2_Param.Torque_Cal_K = Data[1];
						SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_TORQUE_2_CAL_K, sizeof(TorqueSensor_2_Param.Torque_Cal_K), &TorqueSensor_2_Param.Torque_Cal_K);
					}
					else if(Data[0] == 3)
					{
					  TorqueSensor_3_Param.Torque_Cal_K = Data[1];
						SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_TORQUE_3_CAL_K, sizeof(TorqueSensor_3_Param.Torque_Cal_K), &TorqueSensor_3_Param.Torque_Cal_K);
					}
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
					break;
				}
				case 0x3500://查询启动值
				{
				  GetParamFromEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_TORQUE_STARDATA, sizeof(TorqueSensorStartData), Data);
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xB002, Data);
					break;
				}
				
				default:break;
			}
			break;
		}
    case ID_CDL_TO_MC_TE://0X651
    {
      switch(Cmd)
      {
        case 0x2505: case 0xA10B: //TE复位指令和TE升级指令,让主控进入TE升级状态
           IsSendDataToTE_Step = SENDUPDATA;
          break;
        default:
          break;
      }      
      SendUartDataToTE(&UART_TxBuff_Struct3,ID_CDL_TO_MC_TE,Mode,Cmd, Data);//直接透传所有的0X651指令 
      break;
    }      
		default:break;
	}
}
/*********************End*******************/

/************全局函数定义*******************/
//CAN数据解析，严格按照协议格式
uint8_t CAN_RevData[255], CAN_RevData_CRC_Buf[255];
void CAN_RxData_Process(CAN_Buf_TypeDef* ptCANRx, uint16_t TimeOutCnt)
{
  uint8_t Mode, CmdLength, DataLength;
	uint16_t Cmd, i;
	uint32_t CrcResult, CrcData;
	uint8_t FrameBegin1, FrameBegin2;
	
	if(ptCANRx->ucBufCnt >= 11)
	{
	  //读取帧头
		FrameBegin1 = cd_ReadChar(ptCANRx, 0);
		CAN_RevData_CRC_Buf[0] = FrameBegin1;
		FrameBegin2 = cd_ReadChar(ptCANRx, 1);
		CAN_RevData_CRC_Buf[1] = FrameBegin2;
		if((FrameBegin1 == FRAME_BEGIN1) && (FrameBegin2 == FRAME_BEGIN2))
		{
		  CAN_RevData_CRC_Buf[2] = (uint8_t)((ptCANRx->ucBufID >> 8) & 0xFF);
			CAN_RevData_CRC_Buf[3] = (uint8_t)(ptCANRx->ucBufID & 0xFF);
			//读取帧模式
			Mode = cd_ReadChar(ptCANRx, 2);
			CAN_RevData_CRC_Buf[4] = Mode;
			if((Mode == MODE_READ) || (Mode == MODE_WRITE) || (Mode == MODE_REPORT))
			{
			  //读取命令段长度和命令字
				CmdLength = cd_ReadChar(ptCANRx, 3);
				CAN_RevData_CRC_Buf[5] = CmdLength;
				Cmd = (cd_ReadChar(ptCANRx, 4) << 8) + cd_ReadChar(ptCANRx, 5);
				CAN_RevData_CRC_Buf[6] = (uint8_t)((Cmd >> 8) & 0xFF);
		  	CAN_RevData_CRC_Buf[7] = (uint8_t)(Cmd & 0xFF);
				DataLength = cd_ReadChar(ptCANRx, 5);
				if((CmdLength - DataLength) == 2)
				{
					if(ptCANRx->ucBufCnt < (CmdLength + 9))//帧头2bytes  + 模式1byte + 命令段长度1byte + 校验位4bytes + 帧尾1byte
					{
					  if(ptCANRx->IsWaitRX_Flag == FALSE)
						{
						  ptCANRx->DelayTimeCnt = HAL_GetTick();
							ptCANRx->IsWaitRX_Flag = TRUE;
						}
						if((HAL_GetTick() - ptCANRx->DelayTimeCnt) > TimeOutCnt)//超时，单位ms
						{
						  cd_DelChar(ptCANRx, ptCANRx->ucBufCnt);
							ptCANRx->IsWaitRX_Flag = FALSE;
						}
						return;
					}
					else
					{					  
						ptCANRx->IsWaitRX_Flag = FALSE;
						//接收到完整正确数据包
						for(i=0; i<DataLength; i++)//读取数据段
						{
						  CAN_RevData[i] = cd_ReadChar(ptCANRx, 6 + i);
							CAN_RevData_CRC_Buf[8 + i] = CAN_RevData[i];
						}
						CrcData = (cd_ReadChar(ptCANRx, 6 + DataLength) << 24) + \
						          (cd_ReadChar(ptCANRx, 7 + DataLength) << 16) + \
						          (cd_ReadChar(ptCANRx, 8 + DataLength) << 8) + \
						          cd_ReadChar(ptCANRx, 9 + DataLength);
						CrcResult = CRC32_Calculate(CAN_RevData_CRC_Buf, 8 + DataLength);
						if((CrcData - CrcResult) == 0) // 比较校验
						{
						  //数据处理
							DataProcess(ptCANRx->ucBufID, Mode, Cmd, CAN_RevData);//Mode为帧模式，Cmd为命令字，Data为数据段
							cd_DelChar(ptCANRx, CmdLength + 9);
							return;
						}
						cd_DelChar(ptCANRx, 1);
					}
				}
				else
				{
				  cd_DelChar(ptCANRx, 1);
				}
			}
			else
			{
			  cd_DelChar(ptCANRx, 1);
			}
		}
		else
		{
		  cd_DelChar(ptCANRx, 1);
		}
	}
}
uint8_t CanSendData[255], CanSendData_CRC_Buf[255];
void SendData(uint16_t ID, uint8_t Mode, uint16_t Command, uint8_t* Data)
{
	uint32_t CRC_Result = 0x00000000;
	uint8_t DataLength;
	
	DataLength = (uint8_t)(Command & 0xFF);
	CanSendData[0] = FRAME_BEGIN1;
	CanSendData[1] = FRAME_BEGIN2;	
	CanSendData[2] = Mode;
	CanSendData[3] = DataLength + 2;
	CanSendData[4] = (uint8_t)((Command >> 8) & 0xFF);
	CanSendData[5] = DataLength;
	
	memcpy(CanSendData + 6, Data, DataLength);
	
	CanSendData_CRC_Buf[0] = FRAME_BEGIN1;
	CanSendData_CRC_Buf[1] = FRAME_BEGIN2;
	CanSendData_CRC_Buf[2] = (uint8_t)(ID >> 8);
	CanSendData_CRC_Buf[3] = (uint8_t)(ID & 0xFF);
	memcpy(CanSendData_CRC_Buf + 4, CanSendData + 2, DataLength + 4);
	
	CRC_Result = CRC32_Calculate(CanSendData_CRC_Buf, DataLength + 8);//帧头 2bytes + ID 2bytes + 模式 1byte + 命令段长度 1byte + 命令字 2bytes
	
	CanSendData[6 + DataLength] = (uint8_t)((CRC_Result >> 24) & 0xFF);
	CanSendData[7 + DataLength] = (uint8_t)((CRC_Result >> 16) & 0xFF);
	CanSendData[8 + DataLength] = (uint8_t)((CRC_Result >> 8) & 0xFF);
	CanSendData[9 + DataLength] = (uint8_t)(CRC_Result & 0xFF);
	
	CanSendData[10 + DataLength] = FRAME_END;
	
	CAN_SendData(ID, CanSendData, DataLength + 11);
}

/********************End********************/