motor_ctl-3/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"

/**********局部函数定义**********/
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); 
					//电池通信正常标志置位，用于续航计算
					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();
					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();
					break;
				}
				case 0x120C://PBU物理ID
				{
				  memcpy(PBU_CheckInfo.MAC_ID, Data, DataLength);
					break;
				}
				case 0x130C://PBU存储的校验码
				{
					memcpy(PBU_CheckInfo.CheckCode, Data, DataLength);
					break;
				}
				//PBU发送给MC的指令
				case 0x3002://控制电机指令
				{
				  memcpy(&MC_ControlCode.GearSt, Data, DataLength);
					Update_MC_ControlCode_Back();
		      MC_RunInfo.GearSt = MC_ControlCode.GearSt;//当前助力档位更新
					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://控制参数配置
				{
				  memcpy(&PBU_ConfigParam.GearsNum, Data, DataLength);
					SendData(ID_MC_TO_PBU, MODE_REPORT, 0x5303, (uint8_t*)"ACK");
					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);
					break;
				}
				case 0x3100://查询电机配置参数
				{
				  GetParamFromEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_CONFIG_PARAM, sizeof(MC_ConfigParam), &MC_ConfigParam.RS1);
					Data[0] = MC_ConfigParam.WheelSize;
					Data[1] = MC_ConfigParam.StarModel;
					Data[2] = MC_ConfigParam.SpeedLimit;
					SendData(ID_MC_TO_HMI, MODE_REPORT, 0x7308, Data);
					break;
				}
				case 0x3208://设置电机配置参数
				{
					MC_ConfigParam.WheelSize = Data[0];
					MC_ConfigParam.StarModel = (MC_StarMode_Struct_t)Data[1];
					SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_CONFIG_PARAM, sizeof(MC_ConfigParam), &MC_ConfigParam.RS1);
					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;
				}
				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");
					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);
					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);
					EEPROM_Flash_DataUpdate();
					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);
					EEPROM_Flash_DataUpdate();
					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);
					EEPROM_Flash_DataUpdate();
					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;
					break;
				}
				case 0x1A00://查询电机控制参数
				{
				  GetParamFromEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_CONFIG_PARAM, sizeof(MC_ConfigParam), &MC_ConfigParam.RS1);  
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA020, &MC_ConfigParam.RS1);
					break;
				}
				case 0x1B20://写入电机控制参数
				{
				  memcpy(&MC_ConfigParam.RS1, Data, DataLength);
					SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_CONFIG_PARAM, sizeof(MC_ConfigParam), &MC_ConfigParam.RS1);
					//助力参数初始化
	        UpdateGearParam(MC_ConfigParam.SerialNum);
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
					break;
				}
				case 0x1C00://查询马达参数
				{
				  GetParamFromEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_MOTOR_PARAM, sizeof(MC_MotorParam), (uint8_t*)&MC_MotorParam.Rate_Power);
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA110, (uint8_t*)&MC_MotorParam.Rate_Power);
					break;
				}
				case 0x1D10://写入马达参数
				{
				  memcpy((uint8_t*)&MC_MotorParam.Rate_Power, Data, DataLength);
					SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_MOTOR_PARAM, sizeof(MC_MotorParam), (uint8_t*)&MC_MotorParam.Rate_Power);
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
					break;
				}
				case 0x1E00://查询电机历史信息
				{
				  uint32_t DataTemp;
					GetParamFromEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_RUN_LOG, sizeof(MC_RunLog), (uint8_t*)&MC_RunLog.PowerOnCnt);
					DataTemp = MC_RunLog.ODO_Km;
					MC_RunLog.ODO_Km = DataTemp / 10; // 存储按照0.1km,发送按照1km
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA230, (uint8_t*)&MC_RunLog.PowerOnCnt);
					MC_RunLog.ODO_Km = DataTemp;
					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://查询力矩传感器零偏数据
				{
				  GetParamFromEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_TORQUE_OFFSET, sizeof(TorqueOffSetData), (uint8_t*)TorqueOffSetData.Data);
					SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA318, (uint8_t*)TorqueOffSetData.Data);
					break;
				}
				case 0x2100://查询设备在线结果
				{
				  SendData(ID_MC_BC, MODE_REPORT, 0x1401, &DeviceOnLine_Status.Status);
					break;
				}
				case 0x2210://写入电机Mode
				{
				  memcpy(MC_VerInfo.Mode, Data, DataLength);
					EEPROM_Flash_DataUpdate();
					SendData(ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
					break;
				}
				case 0x2310://写入电机SN
				{
				  memcpy(MC_VerInfo.SN_Num, Data, DataLength);
					EEPROM_Flash_DataUpdate();
					SendData(ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
					break;
				}
				case 0x2420://写入电机生产信息
				{
				  memcpy(MC_MacInfo.Manufacturer, Data, DataLength);
					EEPROM_Flash_DataUpdate();
					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");
						SendCmdData(&UART_TxBuff_Struct3, MODE_WRITE, 0x1205, (uint8_t*)"RESET");
		    	  HAL_Delay(200);
			      __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_END, 0xFF);
						EEPROM_Flash_Erase();
						SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
					  SendCmdData(&UART_TxBuff_Struct3, MODE_WRITE, 0x1205, (uint8_t*)"RESET");
				  	__set_FAULTMASK(1);//关闭所有中断
			      HAL_NVIC_SystemReset();
					}
					
					break;
				}
				case 0x2708://系统还原
				{
				  if(strncmp("RECOVERY", (char*)Data, DataLength) == 0)
					{
					  //...
						
						SendData(ID_MC_TO_CDL, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
					  SendCmdData(&UART_TxBuff_Struct3, MODE_WRITE, 0x1205, (uint8_t*)"RESET");
					  __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;
					SendData(ID_MC_BC, MODE_REPORT, 0x1020, (uint8_t*)&MC_RunInfo.BikeSpeed);
					break;
				}
				case 0x2900://查询力矩传感器校正信息
				{
				  SendData(ID_MC_TO_CDL, MODE_REPORT, 0xAA04, (uint8_t*)&MC_TorqueCorrectParam.StarData);
					break;
				}
				case 0x2A01://写入力矩传感器标定系数
				{
				  memcpy((uint8_t*)&MC_TorqueCorrectParam.K, Data, DataLength);
					SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_TORQUE_PARAM, sizeof(MC_TorqueCorrectParam_Struct_t), (uint8_t*)&MC_TorqueCorrectParam.StarData);
					SendData(ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
					break;
				}
				case 0x2B02://写入力矩传感器启动值
				{
				  memcpy((uint8_t*)&MC_TorqueCorrectParam.StarData, Data, DataLength);
					SaveParamToEEprom_24C02(&I2C_Handle_EEPROM, EEPROM_24C02_ADDR_TORQUE_PARAM, sizeof(MC_TorqueCorrectParam_Struct_t), (uint8_t*)&MC_TorqueCorrectParam.StarData);
				  SendData(ID_MC_BC, MODE_REPORT, 0xA903, (uint8_t*)"ACK");
					break;
				}
				case 0x2C01://设置推行模式最高转速百分比
				{
				  MC_WalkMode_Persent = Data[0];
					break;
				}

				default:break;
			}
			break;
		}
		default:break;
	}
}
/*********************End*******************/

/************全局函数定义*******************/
//CAN数据解析，严格按照协议格式
void CAN_RxData_Process(CAN_Buf_TypeDef* ptCANRx, uint16_t TimeOutCnt)
{
  uint8_t Mode, CmdLength, DataLength, Data[64], CRC_Buf[78];
	uint16_t Cmd, i;
	uint32_t CrcResult, CrcData;
	uint8_t FrameBegin1, FrameBegin2;
	
	if(ptCANRx->ucBufCnt >= 11)
	{
	  //读取帧头
		FrameBegin1 = cd_ReadChar(ptCANRx, 0);
		CRC_Buf[0] = FrameBegin1;
		FrameBegin2 = cd_ReadChar(ptCANRx, 1);
		CRC_Buf[1] = FrameBegin2;
		if((FrameBegin1 == FRAME_BEGIN1) && (FrameBegin2 == FRAME_BEGIN2))
		{
		  CRC_Buf[2] = (uint8_t)((ptCANRx->ucBufID >> 8) & 0xFF);
			CRC_Buf[3] = (uint8_t)(ptCANRx->ucBufID & 0xFF);
			//读取帧模式
			Mode = cd_ReadChar(ptCANRx, 2);
			CRC_Buf[4] = Mode;
			if((Mode == MODE_READ) || (Mode == MODE_WRITE) || (Mode == MODE_REPORT))
			{
			  //读取命令段长度和命令字
				CmdLength = cd_ReadChar(ptCANRx, 3);
				CRC_Buf[5] = CmdLength;
				Cmd = (cd_ReadChar(ptCANRx, 4) << 8) + cd_ReadChar(ptCANRx, 5);
				CRC_Buf[6] = (uint8_t)((Cmd >> 8) & 0xFF);
		  	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++)//读取数据段
						{
						  Data[i] = cd_ReadChar(ptCANRx, 6 + i);
							CRC_Buf[8 + i] = Data[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(CRC_Buf, 8 + DataLength);
						if((CrcData - CrcResult) == 0) // 比较校验
						{
						  //数据处理
							DataProcess(ptCANRx->ucBufID, Mode, Cmd, Data);//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);
		}
	}
}

#if 0
//数据解析，忽略命令字表示的数据长度
void CAN_RxData_Process_Temp(CAN_Buf_TypeDef* ptCANRx, uint16_t TimeOutCnt)
{
  uint8_t Mode, CmdLength, DataLength, Data[64], CRC_Buf[78];
	uint16_t Cmd, i;
	uint32_t CrcResult, CrcData;
	uint8_t FrameBegin1, FrameBegin2;
	
	if(ptCANRx->ucBufCnt >= 11)
	{
	  //读取帧头
		FrameBegin1 = cd_ReadChar(ptCANRx, 0);
		CRC_Buf[0] = FrameBegin1;
		FrameBegin2 = cd_ReadChar(ptCANRx, 1);
		CRC_Buf[1] = FrameBegin2;
		if((FrameBegin1 == FRAME_BEGIN1) && (FrameBegin2 == FRAME_BEGIN2))
		{
		  CRC_Buf[2] = (uint8_t)((ptCANRx->ucBufID >> 8) & 0xFF);
			CRC_Buf[3] = (uint8_t)(ptCANRx->ucBufID & 0xFF);
			//读取帧模式
			Mode = cd_ReadChar(ptCANRx, 2);
			CRC_Buf[4] = Mode;
			if((Mode == MODE_READ) || (Mode == MODE_WRITE) || (Mode == MODE_REPORT))
			{
			  //读取命令段长度和命令字
				CmdLength = cd_ReadChar(ptCANRx, 3);
				CRC_Buf[5] = CmdLength;
				Cmd = (cd_ReadChar(ptCANRx, 4) << 8) + cd_ReadChar(ptCANRx, 5);
				CRC_Buf[6] = (uint8_t)((Cmd >> 8) & 0xFF);
		  	CRC_Buf[7] = (uint8_t)(Cmd & 0xFF);
				DataLength = CmdLength - 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++)//读取数据段
					{
						Data[i] = cd_ReadChar(ptCANRx, 6 + i);
						CRC_Buf[8 + i] = Data[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(CRC_Buf, 8 + DataLength);
					if((CrcData - CrcResult) == 0) // 比较校验
					{
						//数据处理
						DataProcess(ptCANRx->ucBufID, Mode, Cmd, Data);//Mode为帧模式，Cmd为命令字，Data为数据段
						cd_DelChar(ptCANRx, CmdLength + 9);
						return;
					}
					cd_DelChar(ptCANRx, 1);
				}
			}
			else
			{
			  cd_DelChar(ptCANRx, 1);
			}
		}
		else
		{
		  cd_DelChar(ptCANRx, 1);
		}
	}	
}
#endif

void SendData(uint16_t ID, uint8_t Mode, uint16_t Command, uint8_t* Data)
{
  uint8_t SendBuf[96] = {0};
	uint8_t CRC_Buf[98] = {0};
	uint32_t CRC_Result = 0x00000000;
	uint8_t DataLength;
	
	DataLength = (uint8_t)(Command & 0xFF);
	SendBuf[0] = FRAME_BEGIN1;
	SendBuf[1] = FRAME_BEGIN2;	
	SendBuf[2] = Mode;
	SendBuf[3] = DataLength + 2;
	SendBuf[4] = (uint8_t)((Command >> 8) & 0xFF);
	SendBuf[5] = DataLength;
	
	memcpy(SendBuf + 6, Data, DataLength);
	
	CRC_Buf[0] = FRAME_BEGIN1;
	CRC_Buf[1] = FRAME_BEGIN2;
	CRC_Buf[2] = (uint8_t)(ID >> 8);
	CRC_Buf[3] = (uint8_t)(ID & 0xFF);
	memcpy(CRC_Buf + 4, SendBuf + 2, DataLength + 4);
	
	CRC_Result = CRC32_Calculate(CRC_Buf, DataLength + 8);//帧头 2bytes + ID 2bytes + 模式 1byte + 命令段长度 1byte + 命令字 2bytes
	
	SendBuf[6 + DataLength] = (uint8_t)((CRC_Result >> 24) & 0xFF);
	SendBuf[7 + DataLength] = (uint8_t)((CRC_Result >> 16) & 0xFF);
	SendBuf[8 + DataLength] = (uint8_t)((CRC_Result >> 8) & 0xFF);
	SendBuf[9 + DataLength] = (uint8_t)(CRC_Result & 0xFF);
	
	SendBuf[10 + DataLength] = FRAME_END;
	
	CAN_SendData(ID, SendBuf, DataLength + 11);
}

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