cdl_tool/MOTINOVA_CDL_App/Src/uart_process.c

#include "can_process.h"
#include "uart_process.h"
#include "crc_cal.h"
#include "stdlib.h"
#include "stdio.h"
#include "string.h"
#include "encrypt.h"
#include "Update.h"
#include "ctf_process.h"
#include "flash.h"

uint8_t Power_mode = 0;//0-default,1-off,2-on
uint32_t T_startPowerOnOff = 0;
uint8_t UART1_BaudrateSwitch = 0;
uint32_t T_UART1_BaudrateSwitch = 0;//0-9600bps,1-57600bps,2-ready to switch baudrate to 57600bps
uint32_t T_RecvCANMsg = 0;
uint32_t T_RecvUartMsg = 0;

uint8_t Transmit_UARTOrCAN = 1;//0-both,1-CAN,2-UART
uint32_t Uart_BootBaudrate = 57600;
uint32_t Uart_AppBaudrate = 9600;
uint32_t CAN_Baudrate = 250;

uint32_t HandingFlag_Enable = 0;
uint32_t PowerOnHandingFlag = 0;
uint32_t T_PowerOnHanding = 0;

void UART1_BaudrateCheck(void)
{
		if(UART1_BaudrateSwitch == 2)
		{
				if((HAL_GetTick() - T_UART1_BaudrateSwitch)>50)
				{
						UART1_BaudrateSwitch = 1;
						MX_USART1_Reopen(Uart_BootBaudrate);
				}
		}
		else if(UART1_BaudrateSwitch == 1)
		{
				if((HAL_GetTick() - T_UART1_BaudrateSwitch)>5000)
				{
						UART1_BaudrateSwitch = 0;
						MX_USART1_Reopen(Uart_AppBaudrate);
				}
		}
}
uint8_t Transmit_UARTOrCAN_pre = 0;//0-both,1-CAN,2-UART
void MsgModeCheck(void)
{
		Transmit_UARTOrCAN_pre = Transmit_UARTOrCAN;
		if(((HAL_GetTick() - T_RecvCANMsg) > 30000) && ((HAL_GetTick() - T_RecvUartMsg) > 30000))
		{
				Transmit_UARTOrCAN = 0;//超过x秒未收到UART和CAN数据进入模式0，下次通信同时发送CAN和UART数据
		}
		else if(((HAL_GetTick() - T_RecvCANMsg) < 5000)&&(T_RecvCANMsg>0))
		{
				Transmit_UARTOrCAN = 1;
		}
		else if(((HAL_GetTick() - T_RecvUartMsg) < 5000)&&(T_RecvUartMsg>0))
		{
				Transmit_UARTOrCAN = 2;
		}
		else if((T_RecvCANMsg == 0)&&(T_RecvUartMsg == 0))
		{
				Transmit_UARTOrCAN = 0;
		}
		
		if(Transmit_UARTOrCAN_pre != Transmit_UARTOrCAN)
		{
				if(Transmit_UARTOrCAN == 2)
				{
						HAL_Delay(100);
						HAL_GPIO_WritePin(CommSwitch_GPIO_Port, CommSwitch_Pin1, GPIO_PIN_SET);
						HAL_GPIO_WritePin(CommSwitch_GPIO_Port, CommSwitch_Pin2, GPIO_PIN_SET);
				}
				else
				{
						HAL_Delay(100);
						HAL_GPIO_WritePin(CommSwitch_GPIO_Port, CommSwitch_Pin1, GPIO_PIN_RESET);
						HAL_GPIO_WritePin(CommSwitch_GPIO_Port, CommSwitch_Pin2, GPIO_PIN_RESET);
				}
		}
}

void PowerOnOff(uint8_t *mode)
{
	if(*mode == 1)
	{
		if((HAL_GetTick() - T_startPowerOnOff) >= 1000)//Off延时1s
		{
			HAL_GPIO_WritePin(ACC_WELLING_EN_GPIO_Port, ACC_WELLING_EN_Pin, GPIO_PIN_RESET);//Off
			*mode = 0;
		}
	}
	else if(*mode == 2)
	{
		if((HAL_GetTick() - T_startPowerOnOff) >= 3000)//On延时3s
		{
			HAL_GPIO_WritePin(ACC_WELLING_EN_GPIO_Port, ACC_WELLING_EN_Pin, GPIO_PIN_RESET);//Off
			*mode = 0;
		}
	}
	
		if(HandingFlag_Enable == 1)//使能
		{
				if(PowerOnHandingFlag == 1)//开机
				{
						if((HAL_GetTick() - T_PowerOnHanding) >= 1000)//开机延时1s
						{
								PowerOnHandingFlag = 0;
								uint8_t Data[2] = {0,0};
								UART_SendSwitch_Lidian2(&UART_TxBuff_Struct1, 0x01, 0x7702, Data);
								HAL_Delay(50);
								UART_SendSwitch_zhihuigainian(&UART_TxBuff_Struct1, 0x7702, Data);
								HAL_Delay(50);
						}
				}
		}
}
//命令处理
static void UART3_DataProcess(uint8_t Mode, uint16_t Command, uint8_t* Data)
{
	switch(Command)
	{
	  //CDL在线检测
		case 0x1100:
		{
			SendCmdData(&UART_TxBuff_Struct3, MODE_REPORT, 0x07FF, 0x1100, (uint8_t*)NULL);
			break;
		}
		//设备开关机
		case 0x2201:
		{
			if(Power_mode == 0)
			{
				T_startPowerOnOff = HAL_GetTick();
				
				if(Data[0] == 0xF0)//关机
				{			
					Power_mode = 1;
					HAL_GPIO_WritePin(ACC_WELLING_EN_GPIO_Port, ACC_WELLING_EN_Pin, GPIO_PIN_SET);//On
				}
				else if(Data[0] == 0xF1)//开机
				{
					Power_mode = 2;
					HAL_GPIO_WritePin(ACC_WELLING_EN_GPIO_Port, ACC_WELLING_EN_Pin, GPIO_PIN_SET);//On
				}
			}
			
		  if(Data[0] == 0xF0)//关机
			{
//			  HAL_GPIO_WritePin(SwitchOnOrOff_GPIO_Port, SwitchOnOrOff_Pin, GPIO_PIN_RESET);
			  HAL_GPIO_WritePin(ACC_MOTINOVA_EN_GPIO_Port, ACC_MOTINOVA_EN_Pin, GPIO_PIN_RESET);
			}
			else if(Data[0] == 0xF1)//开机
			{
				PowerOnHandingFlag = 1;
				T_PowerOnHanding = HAL_GetTick();
				
//			  HAL_GPIO_WritePin(SwitchOnOrOff_GPIO_Port, SwitchOnOrOff_Pin, GPIO_PIN_SET);
			  HAL_GPIO_WritePin(ACC_MOTINOVA_EN_GPIO_Port, ACC_MOTINOVA_EN_Pin, GPIO_PIN_SET);
			}
			break;
		}
		//复位
		case 0x4400:
		{
		  Refresh_Flag();
			__set_FAULTMASK(1);//关闭所有中断
			HAL_NVIC_SystemReset();
			break;
		}
		case 0x4508:
		{
			if (strncmp("CDLRESET", (char *)Data, 8) == 0)
			{
				//重启
				__set_FAULTMASK(1);//关闭所有中断
				HAL_NVIC_SystemReset();
			}
			break;
		}
		case 0x2505:
		{
			if (strncmp("RESET", (char *)Data, 5) == 0)
			{
//				UART_TransferData(&UART_TxBuff_Struct1, UARTID_CDL_TO_MC, Mode, 0x751, Command, Data);
//				HAL_Delay(200);
//				
//				__set_FAULTMASK(1);//关闭所有中断
//				HAL_NVIC_SystemReset();
						T_UART1_BaudrateSwitch = HAL_GetTick();
						UART1_BaudrateSwitch = 2;
			}
			break;
		}
		//随机码和密钥进行校验
		case 0x5514:
		{
		  static uint8_t InputCode[12];
			static uint8_t InputKey[8];
			static uint8_t OutputCode[12];
			static uint8_t SendData[27];
			
			memcpy(InputCode, Data, 12);
			memcpy(InputKey, Data + 12, 8);
			CheckCodeCal(InputCode, InputKey, OutputCode);
			memcpy(SendData, OutputCode, 12);
			memcpy(SendData + 12, (uint8_t*)"V4.1.3_20240907", 15);
			
			SendCmdData(&UART_TxBuff_Struct3, MODE_REPORT, 0x07FF, 0x551B, SendData);
			break;
		}
		//授权
		case 0x6600:
		{
		  uint8_t SendData[24];
			Ctf_CalAndSave();
			memcpy(SendData, MAC_ID, 12);	
			memcpy(SendData + 12, Check_Code, 12);
			SendCmdData(&UART_TxBuff_Struct3, MODE_REPORT, 0x07FF, 0x6618, SendData);
			HAL_Delay(200);
			__set_FAULTMASK(1);//关闭所有中断
			HAL_NVIC_SystemReset();
			break;
		}
		case 0x7702:
		{
		  UART_SendSwitch_Lidian2(&UART_TxBuff_Struct1, 0x01, Command, Data);
			HAL_Delay(50);
			UART_SendSwitch_zhihuigainian(&UART_TxBuff_Struct1, Command, Data);
			HAL_Delay(50);
			break;
		}
		case 0x8000:
		{
			uint8_t SendData[4];
			
			Transmit_UARTOrCAN = (uint8_t)FLASH_Read(CDLPROPERTIES_AREA_ADDRESS, 1);
			SendData[0] = 0;
			SendData[1] = 0;
			SendData[2] = 0;
			SendData[3] = Transmit_UARTOrCAN;
			
		  SendCmdData(&UART_TxBuff_Struct3, MODE_REPORT, 0x07FF, 0x8004, SendData);
			HAL_Delay(50);
			break;
		}
		case 0x8104:
		{
			Transmit_UARTOrCAN = Data[3];
			FLASH_WriteCDLProperties(CDLPROPERTIES_AREA_ADDRESS);
			
			SendCmdData(&UART_TxBuff_Struct3, MODE_REPORT, 0x07FF, 0x8002, (uint8_t*)"OK");
			break;
		}
		case 0x8200:
		{
			uint8_t SendData[4];
			
			Uart_BootBaudrate = FLASH_Read(CDLPROPERTIES_AREA_ADDRESS+4, 1);
			SendData[0] = (uint8_t)((Uart_BootBaudrate >> 24) & 0xFF);
			SendData[1] = (uint8_t)((Uart_BootBaudrate >> 16) & 0xFF);
			SendData[2] = (uint8_t)((Uart_BootBaudrate >> 8) & 0xFF);
			SendData[3] = (uint8_t)((Uart_BootBaudrate >> 0) & 0xFF);
			
		  SendCmdData(&UART_TxBuff_Struct3, MODE_REPORT, 0x07FF, 0x8204, SendData);
			HAL_Delay(50);
			break;
		}
		case 0x8304:
		{
			Uart_BootBaudrate = (uint32_t)((Data[0]<<24) + (Data[1]<<16) + (Data[2]<<8) +(Data[3]));
			FLASH_WriteCDLProperties(CDLPROPERTIES_AREA_ADDRESS);
			
			SendCmdData(&UART_TxBuff_Struct3, MODE_REPORT, 0x07FF, 0x8002, (uint8_t*)"OK");
			break;
		}
		case 0x8400:
		{
			uint8_t SendData[4];
			
			Uart_AppBaudrate = FLASH_Read(CDLPROPERTIES_AREA_ADDRESS+8, 1);
			SendData[0] = (uint8_t)((Uart_AppBaudrate >> 24) & 0xFF);
			SendData[1] = (uint8_t)((Uart_AppBaudrate >> 16) & 0xFF);
			SendData[2] = (uint8_t)((Uart_AppBaudrate >> 8) & 0xFF);
			SendData[3] = (uint8_t)((Uart_AppBaudrate >> 0) & 0xFF);
			
		  SendCmdData(&UART_TxBuff_Struct3, MODE_REPORT, 0x07FF, 0x8404, SendData);
			HAL_Delay(50);
			break;
		}
		case 0x8504:
		{
			Uart_AppBaudrate = (uint32_t)((Data[0]<<24) + (Data[1]<<16) + (Data[2]<<8) +(Data[3]));
			FLASH_WriteCDLProperties(CDLPROPERTIES_AREA_ADDRESS);
			
			SendCmdData(&UART_TxBuff_Struct3, MODE_REPORT, 0x07FF, 0x8002, (uint8_t*)"OK");
			break;
		}
		case 0x8600:
		{
			uint8_t SendData[4];
			
			CAN_Baudrate = FLASH_Read(CDLPROPERTIES_AREA_ADDRESS+12, 1);
			SendData[0] = (uint8_t)((CAN_Baudrate >> 24) & 0xFF);
			SendData[1] = (uint8_t)((CAN_Baudrate >> 16) & 0xFF);
			SendData[2] = (uint8_t)((CAN_Baudrate >> 8) & 0xFF);
			SendData[3] = (uint8_t)((CAN_Baudrate >> 0) & 0xFF);
			
		  SendCmdData(&UART_TxBuff_Struct3, MODE_REPORT, 0x07FF, 0x8604, SendData);
			HAL_Delay(50);
			break;
		}
		case 0x8704:
		{
			CAN_Baudrate = (uint32_t)((Data[0]<<24) + (Data[1]<<16) + (Data[2]<<8) +(Data[3]));
			FLASH_WriteCDLProperties(CDLPROPERTIES_AREA_ADDRESS);
			
			SendCmdData(&UART_TxBuff_Struct3, MODE_REPORT, 0x07FF, 0x8002, (uint8_t*)"OK");
			break;
		}
		case 0x8800:
		{
			uint8_t SendData[4];
			
			HandingFlag_Enable = FLASH_Read(CDLPROPERTIES_AREA_ADDRESS+16, 1);
			SendData[0] = (uint8_t)((HandingFlag_Enable >> 24) & 0xFF);
			SendData[1] = (uint8_t)((HandingFlag_Enable >> 16) & 0xFF);
			SendData[2] = (uint8_t)((HandingFlag_Enable >> 8) & 0xFF);
			SendData[3] = (uint8_t)((HandingFlag_Enable >> 0) & 0xFF);
			
		  SendCmdData(&UART_TxBuff_Struct3, MODE_REPORT, 0x07FF, 0x8804, SendData);
			HAL_Delay(50);
			break;
		}
		case 0x8904:
		{
			HandingFlag_Enable = (uint32_t)((Data[0]<<24) + (Data[1]<<16) + (Data[2]<<8) +(Data[3]));
			FLASH_WriteCDLProperties(CDLPROPERTIES_AREA_ADDRESS);
			
			SendCmdData(&UART_TxBuff_Struct3, MODE_REPORT, 0x07FF, 0x8002, (uint8_t*)"OK");
			break;
		}
		default:break;
	}
}


static void UART1_DataProcess(uint8_t Mode, uint16_t Command, uint8_t* Data)
{
	
}
//发送数据

void UART_SendSwitch_Lidian2(USART_Buf_TypeDef * ptTx, uint8_t Addr, uint16_t Cmd, uint8_t* Data)
{
	uint8_t databuf[256] = {0};
	uint8_t i = 0;
	uint8_t len = 0;
	uint16_t checkxor = 0;
	
	len = 20;
	
	databuf[0] = Addr;
	databuf[1] = len;
	databuf[2] = (uint8_t)((Cmd >> 8) & 0xFF);
	
	for(i=0; i<(Cmd & 0xFF); i++)
	{
		databuf[3+i] = Data[i];
	}
	
	for(i=0; i<len; i++)
	{
		checkxor ^= databuf[i];
	}
	
	databuf[len-1] = checkxor;
	
	UART_SendData(ptTx, databuf, len);
}

void UART_SendSwitch_zhihuigainian(USART_Buf_TypeDef * ptTx, uint16_t Cmd, uint8_t* Data)
{
	uint8_t databuf[256] = {0};
	uint8_t i = 0;
	uint8_t len = 0;
	uint16_t checkxor = 0;
	
	len = 13;
	
	databuf[0] = 0x55;
	
	for(i=0; i<(Cmd & 0xFF); i++)
	{
		databuf[1+i] = Data[i];
	}
	
	for(i=0; i<10; i=i+2)
	{
		checkxor ^= (uint16_t)((databuf[i]<<8) + databuf[i+1]);
	}
	
	databuf[len-3] = (uint8_t)(checkxor&0xff);
	databuf[len-2] = (uint8_t)(checkxor>>8);
	databuf[len-1] = 0xF0;
	
	UART_SendData(ptTx, databuf, len);
}

void UART_TransferData(USART_Buf_TypeDef * ptTx, uint8_t Addr, uint8_t Mode, uint16_t ID, uint16_t Cmd, uint8_t* Data)
{
  uint8_t databuf[256] = {0};
	uint8_t i = 0;
	uint8_t len = 0;
	uint16_t checksum = 0;
	
	len = (uint8_t)((Cmd & 0xff) + 4);
	if(len > 247)
	{
		len = 247;
	}
	
	databuf[0] = UARTFRAME_BEGIN;
	databuf[1] = Addr;
	databuf[2] = Mode;
	databuf[3] = len;
	databuf[4] = (uint8_t)((ID >> 8) & 0xFF);
	databuf[5] = (uint8_t)(ID & 0xFF);
	databuf[6] = (uint8_t)((Cmd >> 8) & 0xFF);
	databuf[7] = (uint8_t)(Cmd & 0xFF);
	
	for(i=0; i<(len-4); i++)
	{
		databuf[8+i] = Data[i];
	}
	
	for(i=1; i<(len+4); i++)
	{
		checksum = (uint16_t)(databuf[i] + checksum);
	}
	
	databuf[4+len] = (uint8_t)checksum;
	databuf[5+len] = (uint8_t)(checksum>>8);
	databuf[6+len] = UARTFRAME_END1;
	databuf[7+len] = UARTFRAME_END2;
	
	UART_SendData(ptTx, databuf, len + 8);
}

void SendCmdData(USART_Buf_TypeDef * ptTx, uint8_t Mode, uint16_t ID, uint16_t Command, uint8_t* Data)
{
  uint8_t SendBuf[255] = {0};
	uint8_t CRC_Buf[255] = {0};
	uint32_t CRC_Result = 0x00000000;
	uint8_t DataLength;
	
	DataLength = (uint8_t)(Command & 0xFF);
	SendBuf[0] = FRAME_BEGIN1;
	SendBuf[1] = FRAME_BEGIN2;
	SendBuf[2] = (uint8_t)((ID >> 8) & 0xFF);
	SendBuf[3] = (uint8_t)(ID & 0xFF);
	SendBuf[4] = Mode;
	SendBuf[5] = DataLength + 2;
	SendBuf[6] = (uint8_t)((Command >> 8) & 0xFF);
	SendBuf[7] = DataLength;
	memcpy(SendBuf + 8, Data, DataLength);
	memcpy(CRC_Buf, SendBuf, 8 + DataLength);
	
	CRC_Result = CRC32_Calculate(CRC_Buf, DataLength + 8);
	
	SendBuf[8 + DataLength] = (uint8_t)((CRC_Result >> 24) & 0xFF);
	SendBuf[9 + DataLength] = (uint8_t)((CRC_Result >> 16) & 0xFF);
	SendBuf[10 + DataLength] = (uint8_t)((CRC_Result >> 8) & 0xFF);
	SendBuf[11 + DataLength] = (uint8_t)(CRC_Result & 0xFF);
	
	SendBuf[12 + DataLength] = FRAME_END;
	
	UART_SendData(ptTx, SendBuf, DataLength + 13);
}

//串口1数据解析
void Uart1_RxData_Process(USART_Buf_TypeDef* ptUartRx, uint16_t TimeOut)
{
  uint8_t Mode, DataLength, Addr;
  static 	uint8_t	Data[255];
	uint16_t Cmd, i, ID;
	uint16_t CheckSumResult=0, CheckSumData=0;
	uint8_t FrameBegin, FrameEnd1, FrameEnd2;
	static uint32_t DelayTimeCnt = 0;
	static TrueOrFalse_Flag_Struct_t IsWaitRX_Flag = FALSE;
	
	if(ptUartRx->ucBufCnt >= 8)
	{
	  //读取帧头
		FrameBegin = UART_ReadChar(ptUartRx, 0);

		if(FrameBegin == UARTFRAME_BEGIN)
		{
		  Addr = UART_ReadChar(ptUartRx, 1);//读取地址ID

			if(Addr == UARTADDR_CDL)
			{
					//读取帧模式
				Mode = UART_ReadChar(ptUartRx, 2);
				
				if((Mode == UARTMODE_READ) || (Mode == UARTMODE_WRITE) || (Mode == UARTMODE_REPORT))
				{
					//读取数据段长度
					DataLength = UART_ReadChar(ptUartRx, 3);
					
					if(ptUartRx->ucBufCnt < (DataLength + 8))//帧头1byte  + 地址1byte + 模式1byte + 长度1byte + 校验位2bytes + 帧尾2bytes
					{
						if(IsWaitRX_Flag == FALSE)
						{
							DelayTimeCnt = HAL_GetTick();
							IsWaitRX_Flag = TRUE;
						}
						if((HAL_GetTick() - DelayTimeCnt) > TimeOut)//超时，单位ms
						{
							UART_DelChar(ptUartRx, ptUartRx->ucBufCnt);
							IsWaitRX_Flag = FALSE;
						}
						return;
					}
					else
					{
						T_RecvUartMsg = HAL_GetTick();
						IsWaitRX_Flag = FALSE;
						//接收到完整正确数据包
						for(i=0; i<(DataLength+4); i++)//读取数据段
						{
							Data[i] = UART_ReadChar(ptUartRx, i);
						}
						CheckSumData = (UART_ReadChar(ptUartRx, 4 + DataLength)) + \
														(UART_ReadChar(ptUartRx, 5 + DataLength) << 8);
						for(i = 1; i<(DataLength+4); i++)
						{
							CheckSumResult = (uint16_t)(Data[i] + CheckSumResult);
						}
						
						FrameEnd1 = UART_ReadChar(ptUartRx, 6 + DataLength);
						FrameEnd2 = UART_ReadChar(ptUartRx, 7 + DataLength);

						if((CheckSumData == CheckSumResult) && (FrameEnd1 == UARTFRAME_END1) && (FrameEnd2 == UARTFRAME_END2))// 比较校验和帧尾
						{
							//数据处理
							UART1_DataProcess(Mode, Cmd, &Data[4]);//Mode为帧模式，Cmd为命令字，Data为数据段
							
							if(DataLength >= 4)//数据段包含ID+Cmd，至少4bytes
							{
								ID = (uint16_t)((Data[4]<<8) + Data[5]);
								Cmd = (uint16_t)((Data[6]<<8) + Data[7]);
								SendCmdData(&UART_TxBuff_Struct3, Mode, ID, Cmd, &Data[8]);
							}
							
							if((Cmd==0xC109) || (Cmd==0xC202) || (Cmd==0xC302) || (Cmd==0xC402) || (Cmd==0xC502))
							{
									T_UART1_BaudrateSwitch = HAL_GetTick();
							}
							//清除缓存
							UART_DelChar(ptUartRx, DataLength + 8);
							//通信指示
							HAL_GPIO_TogglePin(LED_Display_GPIO_Port, LED_Display_Pin);
						}
						else
						{
							UART_DelChar(ptUartRx, 1);
						}
					}
				}
				else
				{
				  UART_DelChar(ptUartRx, 1);
				}
			}
			else
			{
			  UART_DelChar(ptUartRx, 1);
			}
		}
		else
		{
		  UART_DelChar(ptUartRx, 1);
		}
	}
}

//串口3数据解析
void Uart3_RxData_Process(USART_Buf_TypeDef* ptUartRx, uint16_t TimeOut)
{
  uint8_t Mode, CmdLength, DataLength;
  static 	uint8_t	Data[255], CRC_Buf[255];
	uint16_t Cmd, i, ID;
	uint32_t CrcResult, CrcData;
	uint8_t FrameBegin1, FrameBegin2;
	static uint32_t DelayTimeCnt = 0;
	static TrueOrFalse_Flag_Struct_t IsWaitRX_Flag = FALSE;
	
	if(ptUartRx->ucBufCnt >= 13)
	{
	  //读取帧头
		FrameBegin1 = UART_ReadChar(ptUartRx, 0);
		CRC_Buf[0] = FrameBegin1;
		FrameBegin2 = UART_ReadChar(ptUartRx, 1);
		CRC_Buf[1] = FrameBegin2;
		if((FrameBegin1 == FRAME_BEGIN1) && (FrameBegin2 == FRAME_BEGIN2))
		{
		  CRC_Buf[2] = UART_ReadChar(ptUartRx, 2);
			CRC_Buf[3] = UART_ReadChar(ptUartRx, 3);
			ID = (uint16_t)(CRC_Buf[2] << 8) + CRC_Buf[3];
			//读取帧模式
			Mode = UART_ReadChar(ptUartRx, 4);
			CRC_Buf[4] = Mode;
			if((Mode == MODE_READ) || (Mode == MODE_WRITE) || (Mode == MODE_REPORT))
			{
			  //读取命令段长度和命令字
				CmdLength = UART_ReadChar(ptUartRx, 5);
				CRC_Buf[5] = CmdLength;
				Cmd = (UART_ReadChar(ptUartRx, 6) << 8) + UART_ReadChar(ptUartRx, 7);
				CRC_Buf[6] = (uint8_t)((Cmd >> 8) & 0xFF);
		  	CRC_Buf[7] = (uint8_t)(Cmd & 0xFF);
				DataLength = UART_ReadChar(ptUartRx, 7);
				if((CmdLength - DataLength) == 2)
				{
					if(ptUartRx->ucBufCnt < (CmdLength + 11))//帧头2bytes  + ID2bytes 模式1byte + 命令段长度1byte + 校验位4bytes + 帧尾1byte
					{
					  if(IsWaitRX_Flag == FALSE)
						{
						  DelayTimeCnt = HAL_GetTick();
							IsWaitRX_Flag = TRUE;
						}
						if((HAL_GetTick() - DelayTimeCnt) > TimeOut)//超时，单位ms
						{
						  UART_DelChar(ptUartRx, ptUartRx->ucBufCnt);
							IsWaitRX_Flag = FALSE;
						}
						return;
					}
					else
					{					  
						IsWaitRX_Flag = FALSE;
						//接收到完整正确数据包
						for(i=0; i<DataLength; i++)//读取数据段
						{
						  Data[i] = UART_ReadChar(ptUartRx, 8 + i);
							CRC_Buf[8 + i] = Data[i];
						}
						CrcData = (UART_ReadChar(ptUartRx, 8 + DataLength) << 24) + \
						          (UART_ReadChar(ptUartRx, 9 + DataLength) << 16) + \
						          (UART_ReadChar(ptUartRx, 10 + DataLength) << 8) + \
						           UART_ReadChar(ptUartRx, 11 + DataLength);
						CrcResult = CRC32_Calculate(CRC_Buf, 8 + DataLength);
						if((CrcData - CrcResult) == 0) // 比较校验
						{
						  //数据处理
							UART3_DataProcess(Mode, Cmd, Data);//Mode为帧模式，Cmd为命令字，Data为数据段
							//数据转发CAN
							memcpy((uint8_t*)(CRC_Buf + 2), (uint8_t*)(CRC_Buf + 4), DataLength + 4);
							CRC_Buf[6 + DataLength] = UART_ReadChar(ptUartRx, 8 + DataLength);
							CRC_Buf[7 + DataLength] = UART_ReadChar(ptUartRx, 9 + DataLength);
							CRC_Buf[8 + DataLength] = UART_ReadChar(ptUartRx, 10 + DataLength);
							CRC_Buf[9 + DataLength] = UART_ReadChar(ptUartRx, 11 + DataLength);
							CRC_Buf[10 + DataLength] = FRAME_END;
							CAN_SendData(ID, CRC_Buf, DataLength + 11);
							
							UART_TransferData(&UART_TxBuff_Struct1, UARTADDR_CDL, Mode, ID, Cmd, Data);
							//清除缓存
							UART_DelChar(ptUartRx, CmdLength + 11);
							//通信指示
							HAL_GPIO_TogglePin(LED_Display_GPIO_Port, LED_Display_Pin);
							return;
						}
						UART_DelChar(ptUartRx, 1);
					}
				}
				else
				{
				  UART_DelChar(ptUartRx, 1);
				}
			}
			else
			{
			  UART_DelChar(ptUartRx, 1);
			}
		}
		else
		{
		  UART_DelChar(ptUartRx, 1);
		}
	}
}