MC_Bootloader/user/user_can/can_app.c

/**
  ******************************************************************************
  * @file    can_app.c
  * @author  Vincent
  * @version V1.0.0
  * @date    23-12-2015
  * @brief   
  ******************************************************************************
  *
  * COPYRIGHT(c) 2015 STMicroelectronics
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
  *   1. Redistributions of source code must retain the above copyright notice,
  *      this list of conditions and the following disclaimer.
  *   2. Redistributions in binary form must reproduce the above copyright notice,
  *      this list of conditions and the following disclaimer in the documentation
  *      and/or other materials provided with the distribution.
  *   3. Neither the name of STMicroelectronics nor the names of its contributors
  *      may be used to endorse or promote products derived from this software
  *      without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  ******************************************************************************
  */
/* Includes ------------------------------------------------------------------*/
#include "can_app.h"
#include "RefreshMenu.h"
#include "protocol.h"
//#include "FLASH_Block_Api.h"
#include "string.h"
#include "flash_if.h"
#include "crc_cal.h"
#include "bin_check.h"
/* Private variables ---------------------------------------------------------*/

/*******************************************************************************
* Function: void CAN_RxData_Process(CAN_Buf_TypeDef*ptCANRx)
* Discrible:
* Input:
* Output: 
* Return: 
* Others: 
*    date    version	  author        record
* -----------------------------------------------
* 20151107     V1.0     VINCENT       Create
*********************************************************************************/
void CA_RxData_Process(CAN_Buf_TypeDef*ptCANRx)
{
	CD_UINT8  ucHeadHighByte,ucHeadLowByte,ucFrameMode; 	
  //CD_UINT8  file_headTail[PACKET_128B_SIZE]={0},file_body[PACKET_1K_SIZE]={0};
	CD_UINT16 i ;
	
	CD_UINT8 ucFrameLength,ucTrail;
	CD_UINT16 ucKeyCmd;
	CD_UINT32 ucCRCSum,CrcTemp;
	
	static CD_UINT8 frameCrcBuff[FRAME_DATA_SIZE+2];
	
	if((*ptCANRx).ucBufCnt > 8)
	{
		/*清除超时标志*/
		update.TimeCounter_Update = 0;
		
		ucHeadHighByte = cd_ReadChar(ptCANRx,0);    //帧头1
		ucHeadLowByte = cd_ReadChar(ptCANRx,1);     //帧头2
		
		
		if((PRO_HEAD1 == ucHeadHighByte)&&(PRO_HEAD2 == ucHeadLowByte))
		{
			
			ucFrameMode = cd_ReadChar(ptCANRx,2);         
			ucFrameLength = cd_ReadChar(ptCANRx,3);
			ucKeyCmd = ((CD_UINT16)cd_ReadChar(ptCANRx,4) << 8 ) + ((CD_UINT16)cd_ReadChar(ptCANRx,5));
			
			if( FRAME_MODE_WRITE !=  ucFrameMode)  return;
			
			if((*ptCANRx).ucBufCnt <(ucFrameLength  + 4 + 5 )) return;
			
			frameCrcBuff[0] =  FRAME_HEAD1;
			frameCrcBuff[1] =  FRAME_HEAD2;
			frameCrcBuff[2] =  0x07;
			frameCrcBuff[3] =  0x51;
			
			
			
			ucTrail = cd_ReadChar(ptCANRx,ucFrameLength  + 4 + 4 );
			if(PRO_TAIL !=  ucTrail)
			{
				/*帧尾错误*/
				cd_DelChar(ptCANRx, 1);	
				update.AckEnable =  ENABLE;
				downLoad.userCmd = CMD_ACK_ERR;
				downLoad.step = 0xf0;
				return ; 
			}
			
			ucCRCSum = (cd_ReadChar(ptCANRx,ucFrameLength  + 4 ) << 24) + \
								 (cd_ReadChar(ptCANRx,ucFrameLength  + 4 + 1 ) << 16) + \
								 (cd_ReadChar(ptCANRx,ucFrameLength  + 4 + 2 ) << 8) + \
								 cd_ReadChar(ptCANRx,ucFrameLength  + 4 + 3 ) ;
	
			for(i=2; i< ( ucFrameLength  + 4 ); i++)
			{
				frameCrcBuff[i+2] = cd_ReadChar(ptCANRx,i);
			}
			
			/*CRC 校验*/
			CrcTemp = CRC32_Calculate( (CD_UINT8 *)frameCrcBuff, (ucFrameLength  + 4 + 2 ) );
			if( ucCRCSum !=  CrcTemp)
			{
				update.AckEnable =  ENABLE;
				downLoad.userCmd = CMD_ACK_ERR;
				downLoad.step = 0xf1;
				
				cd_DelChar(ptCANRx, (ucFrameLength  + 4 + 5 ));	
				return ;
			}
			
			cd_DelChar(ptCANRx, (ucFrameLength  + 4 + 5 ));	
			
			switch(ucKeyCmd)
			{
				case CMD_UPDATA:  //升级指令
					//准备升级
			    if(downLoad.step != 1)
					{
						downLoad.step = 1;
						update.AckEnable =  ENABLE;
						downLoad.userCmd = CMD_ACK_REQ;
						downLoad.packageSize = *(uint32_t *)(frameCrcBuff + 15);

						/*清除超时标志*/
						update.TimeCounter_Startup = 0;
					}
					
					break;
				
				case CMD_PACKAGE_DATA:  //数据包
				  //第一包数据为bin文件校验信息
          if(CheckFlag == 0)
					{
					  CheckFlag = 1;
						CheckInfo = (CD_UINT8 *)frameCrcBuff + FRAME_HEAD + PACKAGE_DATA_HEAD + 2;
						//比较文件头
						if(Check_CompareHead(CheckInfo, Check_UUID) == 0)
						{
						  //解密获取bin文件crc32
							Check_CalCrc32(CheckInfo, Crc32_Cal);
							//比较加密信息
							if(Check_CompareEncryptInfo(CheckInfo) == 0)
							{
							  //比较自定义信息
								if(Check_OptionInfo(CheckInfo, OPTIONAL_ADDRESS) == 0)
								{
									//比较校验
									if(Check_CompareXor(CheckInfo) == 0)
									{
										//文件头检验正确
										CheckFlag = 2;	
										/*擦除FLASH，剩余最后8k没有擦除，保留其他功能使用**/
										FLASH_If_Erase(APPLICATION_ADDRESS); //擦除时间约120ms									
										/*清空flash写标志*/
										for(i=0;i<1024;i++)
										{
											flag_FlashWR[i] = 0;
										}
										sendUpdateAck(0xC202, 0x0001);
									}
									else
									{
										//文件头检验异常
										CheckFlag = 3;
										sendUpdateAck(0xC302, 0x0001);
									}
								}
								else
								{
									//文件头检验异常
									CheckFlag = 3;
									sendUpdateAck(0xC302, 0x0001);
								}
							}
							else
							{
							  //文件头检验异常
							  CheckFlag = 3;
								sendUpdateAck(0xC302, 0x0001);
							}
						}
						else
						{
						  //文件头检验异常
						  CheckFlag = 3;
							sendUpdateAck(0xC302, 0x0001);
						}
					}						
				
      	  else if(CheckFlag == 2)
					{
						//校验正确时按照正常流程接收数据
						downLoad.step = 2;
						downLoad.dataBuff_128B = (CD_UINT8 *)frameCrcBuff + FRAME_HEAD + PACKAGE_DATA_HEAD + 2;//帧头(2bytes)+ID(2bytes)+Mode(1bytes)+长度(1byte)+命令字(2bytes)+数据标签(5bytes)
						
						downLoad.packagecount = (frameCrcBuff[10] << 8) + frameCrcBuff[9] - 1; //文件头占用1包，需要减掉
						if(downLoad.packagecount >= 1024)
						{
							downLoad.packagecount = 0;
						}

						downLoad.userCmd = CMD_ACK_OK;
				
						downLoad.wrenable = ENABLE;					
				  }
					break;
					
				case CMD_UPDATA_END:  //结束包
					downLoad.step = 3;
					update.AckEnable =  ENABLE;
					downLoad.userCmd = CMD_ACK_EOT;
		
					break;
				
				case 0x2505:
					downLoad.step = 5;
					update.AckEnable =  ENABLE;
					break;
				
				default:
					cd_DelChar(ptCANRx, 1);
					break;
			}
		}
		else 
		{
			cd_DelChar(ptCANRx, 1);
		}	 
		
  }

}

void sendBootInfo(void)
{
	#if defined CAN_125K
	static CD_UINT8 bootInfoBuff[22]={ FRAME_HEAD1,FRAME_HEAD2,0x07,0x15,0x0C,0x0B,0xC1,0x09,'M','C',' ','V','1','.','5','.','0',0x00,0x00,0x00,0x00,0xF0 };//版本号: MC V2.0.0
	#elif defined CAN_250K
	static CD_UINT8 bootInfoBuff[22]={ FRAME_HEAD1,FRAME_HEAD2,0x07,0x15,0x0C,0x0B,0xC1,0x09,'M','C',' ','V','2','.','5','.','0',0x00,0x00,0x00,0x00,0xF0 };//版本号: MC V2.0.0
  #endif
	CD_UINT32 crc32Ret;
	//static CD_UINT8 ucInit_flag = 0;
	uint8_t i;
		
	crc32Ret = CRC32_Calculate( (CD_UINT8 *)bootInfoBuff,17 );
	
	bootInfoBuff[17] = (CD_UINT8)( crc32Ret >> 24 );
	bootInfoBuff[18] = (CD_UINT8)( crc32Ret >> 16 );
	bootInfoBuff[19] = (CD_UINT8)( crc32Ret >> 8 );
	bootInfoBuff[20] = (CD_UINT8)( crc32Ret );
				
	/*发送第1包数据*/
	hcan.pTxMsg->StdId = CAN_RxBuf_Struct1.ID;
	hcan.pTxMsg->DLC = 8;
	
	hcan.pTxMsg->Data[0] =  bootInfoBuff[0];
	hcan.pTxMsg->Data[1] =  bootInfoBuff[1];
	
	for( i=2;i<8;i++)
	{
		hcan.pTxMsg->Data[i] = bootInfoBuff[i+2];
	}	
	
	if(HAL_CAN_Transmit(&hcan,20) == HAL_ERROR)
	{
		MX_CAN_Init();
	}	
  
  /*发送第2包数据*/
	hcan.pTxMsg->DLC = 8;

	for( i=0;i<8;i++)
	{
		hcan.pTxMsg->Data[i] = bootInfoBuff[i+10];
	}
	
	if(HAL_CAN_Transmit(&hcan,20) == HAL_ERROR)
	{
		MX_CAN_Init();
	}
		
	 /*发送第3包数据*/
	hcan.pTxMsg->DLC = 4;

	for( i=0;i<4;i++)
	{
		hcan.pTxMsg->Data[i] = bootInfoBuff[i+18];
	}
	
	if(HAL_CAN_Transmit(&hcan,20) == HAL_ERROR)
	{
		MX_CAN_Init();
	}
		
}

void sendAck(void)
{
	static CD_UINT8 ackBuff_2[16]={ FRAME_HEAD1,FRAME_HEAD2,0x07,0x15,0x0C,0x05,0xA9,0x03,'A','C','K',0x00,0x00,0x00,0x00,0xF0 };
	CD_UINT32 crc32Ret;
	uint8_t i;
	
	crc32Ret = CRC32_Calculate( (CD_UINT8 *)ackBuff_2,11 );
	
	ackBuff_2[11] = (CD_UINT8)( crc32Ret >> 24 );
	ackBuff_2[12] = (CD_UINT8)( crc32Ret >> 16 );
	ackBuff_2[13] = (CD_UINT8)( crc32Ret >> 8 );
	ackBuff_2[14] = (CD_UINT8)( crc32Ret );
	
	hcan.pTxMsg->StdId = CAN_RxBuf_Struct1.ID;
  hcan.pTxMsg->RTR = CAN_RTR_DATA;
	hcan.pTxMsg->IDE = CAN_ID_STD;	
	/*发送第1包数据*/

	hcan.pTxMsg->DLC = 8;
	
	hcan.pTxMsg->Data[0] =  ackBuff_2[0];
	hcan.pTxMsg->Data[1] =  ackBuff_2[1];
	
	for( i=2;i<8;i++)
	{
		hcan.pTxMsg->Data[i] = ackBuff_2[i+2];
	}	
	
	if(HAL_CAN_Transmit(&hcan,20) == HAL_ERROR)
	{
		MX_CAN_Init();
	}	
  
  /*发送第2包数据*/
	hcan.pTxMsg->DLC = 6;

	for( i=0;i<6;i++)
	{
		hcan.pTxMsg->Data[i] = ackBuff_2[i+10];
	}
	
	if(HAL_CAN_Transmit(&hcan,20) == HAL_ERROR)
	{
		MX_CAN_Init();
	}
}

void sendUpdateAck( CD_UINT16 cmd ,CD_UINT16 packageNum )
{
	static CD_UINT8 ackBuff[15]={ FRAME_HEAD1,FRAME_HEAD2,0x07,0x15,0x0C,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF0 };
	CD_UINT32 crc32Ret;
	//static CD_UINT8 ucInit_flag = 0;
	uint8_t i;
	
	ackBuff[6] = (CD_UINT8)(cmd >>8);
	ackBuff[7] = (CD_UINT8)cmd;
	ackBuff[8] = (CD_UINT8)packageNum;
	ackBuff[9] = (CD_UINT8)(packageNum>>8);
	
	crc32Ret = CRC32_Calculate( (CD_UINT8 *)ackBuff, 10);
	
	ackBuff[10] = (CD_UINT8)( crc32Ret >> 24 );
	ackBuff[11] = (CD_UINT8)( crc32Ret >> 16 );
	ackBuff[12] = (CD_UINT8)( crc32Ret >> 8 );
	ackBuff[13] = (CD_UINT8)( crc32Ret );
	
	hcan.pTxMsg->RTR = CAN_RTR_DATA;
	hcan.pTxMsg->IDE = CAN_ID_STD;	
	/*发送第1包数据*/
	hcan.pTxMsg->StdId = CAN_RxBuf_Struct1.ID;
	hcan.pTxMsg->DLC = 8;
	
	hcan.pTxMsg->Data[0] =  ackBuff[0];
	hcan.pTxMsg->Data[1] =  ackBuff[1];
	
	for( i=2;i<8;i++)
	{
		hcan.pTxMsg->Data[i] = ackBuff[i+2];
	}	
	
	if(HAL_CAN_Transmit(&hcan,20) == HAL_ERROR)
	{
		MX_CAN_Init();
	}	
  
  /*发送第2包数据*/
	hcan.pTxMsg->DLC = 5;

	for( i=0;i<5;i++)
	{
		hcan.pTxMsg->Data[i] = ackBuff[i+10];
	}
	
	if(HAL_CAN_Transmit(&hcan,20) == HAL_ERROR)
	{
		MX_CAN_Init();
	}
}

///*******************************************************************************
//* Function: void A_(uint8_t ucStep,uint8_t ucPackagNum,uint8_t ucAck)
//* Discrible:
//* Input:
//* Output: 
//* Return: 
//* Others: 
//*    date    version	  author        record
//* -----------------------------------------------
//* 20151107     V1.0     VINCENT       Create
//*********************************************************************************/
//void A_(uint8_t ucStep,uint8_t ucPackagNum,uint8_t ucAck)
//{
//	static CD_UINT8 ucInit_flag = 0;
//	static CD_UINT8 ucAckBuf[9] ={'U','P',0x04,0x00,0x02,0x00,0x00,0x00,0xF0};
//	
//	CD_UINT8 ucXor = 0x00;
//	
//	ucXor ^= ucAckBuf[2];
//	ucAckBuf[3] = ucStep;
//	ucXor ^= ucStep;
//	ucXor ^= ucAckBuf[4];
//	ucAckBuf[5] = ucPackagNum;
//	ucXor ^= ucPackagNum;
//	ucAckBuf[6] = ucAck;
//	ucXor ^= ucAck;
//	ucAckBuf[7] = ucXor;
//		
//	if(ucInit_flag == 0)
//	{
//		ucInit_flag = 1;
//		hcan.pTxMsg->ExtId = 0x01;
//		hcan.pTxMsg->RTR = CAN_RTR_DATA;
//		hcan.pTxMsg->IDE = CAN_ID_STD;
//	}
//	
//	hcan.pTxMsg->StdId = CAN_RxBuf_Struct1.ID;
//	hcan.pTxMsg->DLC = 8;
//	memset(hcan.pTxMsg->Data,0,8);
//	for(uint8_t i=0;i<hcan.pTxMsg->DLC;i++)
//	{
//		hcan.pTxMsg->Data[i] = ucAckBuf[i];
//	}	
//	
//	if(HAL_CAN_Transmit(&hcan,20) == HAL_ERROR)
//	{
//		MX_CAN_Init();
//	}	
//  memset(hcan.pTxMsg->Data,0,8);	

//	hcan.pTxMsg->DLC = 1;

//	hcan.pTxMsg->Data[0] = ucAckBuf[8];
//	
//	if(HAL_CAN_Transmit(&hcan,20) == HAL_ERROR)
//	{
//		MX_CAN_Init();
//	}
//}

/************************ (C) END OF FILE *********************************/