GCU-old/IAP-GCU10204-xxV10-dma/User/com.c.bak

/************************************************************************
*	模块名称：com.c
*	程序功能：
*	编 写 者：
*	编写日期：2017-06-22
*	修 改 者：
*	修改日期：
*	编译环境：KEIL4 MDK ARM V4.74
*	硬件平台：STM32F103ZCT6
************************************************************************/
/************************************************************************/
/*                                                                      */
/*                            INCLUDES                                  */
/*                                                                      */
/************************************************************************/
#include <stm32f10x.h>
#include <stm32f10x_dma.h>
#include <string.h>	
#include <stdio.h>
#include "stm32f10x.h"
#include "stm32f10x_usart.h"
#include "stm32f10x_it.h"
#include "com.h"
#include "share.h"
#include "crc.h"

/************************************************************************/
/*                                                                      */
/*                            DEFINITION                                */
/*                                                                      */
/************************************************************************/


/************************************************************************/
/*                                                                      */
/*                            DECLARATION                               */
/*                                                                      */
/************************************************************************/
void delay_ms(uint32_t time);
void ymodem_fun(void);
uint8_t Get_state(void);
uint8_t Dma_send_data(uint8_t *pdata, uint8_t len);

/************************************************************************/
/*                                                                      */
/*                            VARIABLE                                  */
/*                                                                      */
/************************************************************************/
u8	m_SerialSendState = RS_SEND_IDLE;
u8 	m_SerialSendPos   = 0;
u8 	m_SerialSendLen   = 0;
u8 	m_SerialSendBuffer[RS232_MAX_PARAM_LENGTH];

u8 	m_SerialRecvState = RS_RECV_IDLE;
u8 	m_SerialRecvLen   = 0;
u8 	m_SerialRecvPos   = 0;
u8 	m_SerialRecvBuffer[Re_MAX_PARAM_LENGTH];
u8 	m_SerialRecvTransfer[Re_MAX_PARAM_LENGTH];

u16	UpdateCodeData[STM_SECTOR_SIZE/2]	={0};		//1024个半字
u16	CompareaData[STM_SECTOR_SIZE/2]		={0};		//1024个半字

u32	addrCur		=	APPLICATION_PROGRAM_ADDRESS;	//当前写入地址
u32	addrSave	=	APPLICATION_UPDCODE_ADDRESS; //STM32_FLASH_BASE + (STM32_FLASH_SIZE - BACKUP_CODE_CACHE_SIZE) * 1024;		//串口数据保存地址 0x08000000 + (256 - 50)*1024
//u32 RecordAdd;


u16 i = 0;
u8  SectorNum	=	0;//扇区数
u16 m_ReceiveDataCurNum = 0;
u16 m_ReceiveCodeDataU16 		= 0;
u16	m_IAPDateByteTotalSize 		= 0;	//数据总位数
u8	m_IAPDatePackageTotalSize  	= 0;	//数据总包数
u8 	m_IAPDatePackageEND			= 0;	//已经传输完成的包数

u8  m_finish	=	0;

u8  g_IAPCommondFlag	=	0;	//g_skip
u8	CompareFlag = 1;  //
u8	Rewrite=3;

uint8_t	Rx_Flag = 0;
uint8_t Rx_Len = 0;
//static u16 STMFLASH_BUF[STM_SECTOR_SIZE/2];
uint32_t last_upd_ticks = 0;
/***********************************************************************/



/************************************************************************/
/*                                                                      */
/*                            IMPLEMENTATION                            */
/*                                                                      */
/************************************************************************/
uint8_t CheckAddSum(uint8_t *pdata, uint8_t len)
{
	uint16_t sum = 0, i = 0;
	for(i = 0; i<len; i++) {
		sum+=pdata[i];
	}
	return (sum&0xff);
}
uint8_t IsDevCommandFrame(uint8_t *pdata, uint8_t len)
{
	if( len == CMD_UPD_FRAME_LEN && pdata[0] == CMD_FRAME_HEADER && pdata[1] == CMD_UPD_FRAME_LEN
			&& pdata[CMD_UPD_FRAME_LEN - 1] == CheckAddSum(pdata, CMD_UPD_FRAME_LEN-1)) {
				return 1;
	}
	return 0;
}
uint8_t Dma_send_data(uint8_t *pdata, uint8_t len)
{
/*	while(USART_TX_FLAG);                      //等待上一次发送完成（USART2_TX_FLAG为1即还在发送数据）  
	USART_TX_FLAG=1;                           //USART2发送标志（启动发送）  
	USART_DMA_CHANNEL_TX->CMAR  = (uint32_t)pdata; //设置要发送的数据地址  
	USART_DMA_CHANNEL_TX->CNDTR = len;             //设置要发送的字节数目  
	DMA_Cmd(USART_DMA_CHANNEL_TX, ENABLE);             //开始DMA发送  
*/
	while (DMA_GetCurrDataCounter(USART_DMA_CHANNEL_TX));// 检查DMA发送通道内是否还有数据
	if(!len) return 0;// 判断长度是否有效
	if(pdata==NULL) return 0;
	memcpy(Dma_Tx_Buffer, pdata,len);
	//DMA发送数据-要先关 设置发送长度 开启DMA
	DMA_Cmd(USART_DMA_CHANNEL_TX, DISABLE);
	USART_DMA_CHANNEL_TX->CNDTR = len;// 设置发送长度
	DMA_Cmd(USART_DMA_CHANNEL_TX, ENABLE);  // 启动DMA发送
	return len;
}

void DMA2_Channel3_IRQHandler(void)
{
	//USART_PutStr(USART1," DMA23:rn",9);
	DMA_ClearITPendingBit(DMA2_IT_TC3);
	DMA_ClearITPendingBit(DMA2_IT_TE3);

	DMA_Cmd(DMA2_Channel3, DISABLE);         //关闭DMA,防止处理其间有数据

	DMA2_Channel3->CNDTR = DMA_RECV_BUF_SIZE;   //重装填, for receiving

	DMA_Cmd(DMA2_Channel3, ENABLE);          //处理完,重开DMA
}	
void DMA2_Channel4_5_IRQHandler(void)
{
	//USART_PutStr(USART1," DMA245:rn",9);
	DMA_ClearITPendingBit(DMA2_IT_TC5);
	DMA_ClearITPendingBit(DMA2_IT_TE5);

	DMA_Cmd(DMA2_Channel5, DISABLE);         //关闭DMA,防止处理其间有数据

	DMA2_Channel5->CNDTR = 0;   //重装填, for sending

	DMA_Cmd(DMA2_Channel5, ENABLE);          //处理完,重开DMA
}
/***********************************************************************
* 函 数 名: USART1_IRQHandler()
* 功能描述: 系统
* 函数说明:
* 输 		入: 无
* 返 		回:
* 设 计 者：CYL 日期：2015-05-01
* 修 改 者：CYL 日期：2015-05-01
***********************************************************************/
void UART4_IRQHandler(void)
{
	uint16_t data_len, i;
	
	//idle中断	
	if(USART_GetITStatus(USART_NUM, USART_IT_IDLE) != RESET)
	{
		//清除状态寄存器和串口数据寄存器 //	__HAL_UART_CLEAR_IDLEFLAG(&huart2); //
		data_len  =USART_NUM->SR;
		data_len  =USART_NUM->DR;
		//关闭DMA
		DMA_Cmd(USART_DMA_CHANNEL_RX, DISABLE);
		//读取接收buffer的数据
		data_len = DMA_RECV_BUF_SIZE - DMA_GetCurrDataCounter(USART_DMA_CHANNEL_RX);		
		for (i = 0;i < data_len; i++)
		{
			m_SerialRecvBuffer[i]= Dma_Rx_Buffer[i];
			m_SerialRecvPos = i;
		}
		m_SerialRecvLen = data_len;
		//
		DMA_ClearFlag(USART_DMA_RX_CLR_FLAGS); 		
		//设置传输数据长度
		DMA_SetCurrDataCounter(USART_DMA_CHANNEL_RX, DMA_RECV_BUF_SIZE); //USART_DMA_CHANNEL_RX->CNDTR = DMA_RECV_BUF_SIZE;
		//打开DMA
		DMA_Cmd(USART_DMA_CHANNEL_RX, ENABLE);
		USART_ClearITPendingBit(USART_NUM, USART_IT_IDLE);
		
		if(m_SerialRecvState != RS_RECV_COMPLETE) //RecvTemp==m_SerialRecvBuffer[0]
		{   
			Rx_Flag = 0;
			if(IsDevCommandFrame(m_SerialRecvBuffer, m_SerialRecvLen))  //command frame
			{
				if(m_SerialRecvBuffer[2] == CMD_DEV_UPDATE) {  //update command
					Dma_send_data(m_SerialRecvBuffer, m_SerialRecvLen); //ack-update-
					delay_ms(5);  //5ms
					m_SerialRecvState = RS_RECV_COMPLETE;
					g_IAPCommondFlag = 1;
					last_upd_ticks = g_SysTick;
				}
			}
/*			else if(m_SerialRecvBuffer[0] == 0x53 && m_SerialRecvPos == 0x08 && m_SerialRecvBuffer[7] == CheckCrc(&m_SerialRecvBuffer[2],5))
			{
				m_SerialRecvState = RS_RECV_COMPLETE;
				g_IAPCommondFlag = 1;
			}
	*/		
			else {
				m_SerialRecvPos = 0;
				m_SerialRecvLen = 0;
				m_SerialRecvState = RS_RECV_IDLE;
			}
		}
		else //if(m_SerialRecvState == RS_RECV_COMPLETE) 
		{	
			Rx_Flag = 1;
		}
	}		
}
/***********************************************************************
* 函 数 名: DFL_SerialInit()
* 功能描述: 
* 函数说明:
* 输 		入: 无
* 返 		回:
* 设 计 者：CYL 日期：2015-05-23
* 修 改 者：CYL 日期：2015-05-23
***********************************************************************/
void DFL_SerialInit(void)
{
	m_SerialSendState 	= RS_SEND_IDLE;
	m_SerialSendLen    	= 0;
	m_SerialSendPos    	= 0;

	m_SerialRecvState 	= RS_RECV_IDLE;
	m_SerialRecvLen    	= 0;
	m_SerialRecvPos    	= 0;
	return;
}


/***********************************************************************
* 函 数 名: AFL_SerialTask()
* 功能描述: 
* 函数说明:
* 输 		入: 无
* 返 		回:
* 设 计 者：TNT 日期：2015-05-01
* 修 改 者：CYL 日期：2015-05-01
***********************************************************************/
void AFL_SerialTask(void)
{	
	if(m_SerialRecvState != RS_RECV_COMPLETE) 
	{
		return;
	}
	ymodem_fun();
	if(CompareFlag == 0) {
		g_IAPCommondFlag = 9;  //update-error, stop
	}
	if (Get_state() == TO_RECEIVE_END) {
		g_IAPCommondFlag = 2;  //update-end, stop
		AFL_Write_StartMode(Startup_Update);
	} 
	return;

///////////////////////////////////////////////////////	
/*	m_SerialRecvState = RS_RECV_IDLE;
	m_SerialRecvLen    = 0;
	m_SerialRecvPos    = 0;

//-------------------------------------------数据传输-------------------------------
	if(m_SerialRecvBuffer[0] == 0x55 && m_SerialRecvBuffer[1] == 0x55)
	{	 
		
		m_IAPDateByteTotalSize = ((u16)m_SerialRecvBuffer[3] << 8) + ((u16)m_SerialRecvBuffer[4]);
		m_IAPDatePackageTotalSize  = m_SerialRecvBuffer[5];
		
		if(m_SerialRecvBuffer[2] < (m_IAPDatePackageTotalSize - m_IAPDatePackageTotalSize % (STM_SECTOR_SIZE/128)))		//属于整页的数据包
		{
			memcpy(&m_SerialRecvTransfer[0], &m_SerialRecvBuffer[6], Re_MAX_PARAM_LENGTH-7);//取出数据位	
			m_IAPDatePackageEND++;		//已经取出的包数递增
			for(i=0;i<128;i+=2)
			{
				if(m_IAPDatePackageEND - m_SerialRecvBuffer[2] > 1)//是否重发来的数据包
				{
					m_IAPDatePackageEND--;
					break;
				}
				else
				{
					m_ReceiveCodeDataU16 = (((u16)m_SerialRecvTransfer[i+1])<<8) + ((u16)m_SerialRecvTransfer[i]);	//合并
					UpdateCodeData[m_ReceiveDataCurNum] = m_ReceiveCodeDataU16;
					m_ReceiveDataCurNum++;
				}
			}
		
			if(m_ReceiveDataCurNum == STM_SECTOR_SIZE/2)		//满一页就写 
			{
				for(i=0; i<Rewrite; i++)
				{
			
					DHL_STMFlash_Write(addrSave,UpdateCodeData,STM_SECTOR_SIZE/2);	
					DHL_STMFlash_Read(addrSave, CompareaData,STM_SECTOR_SIZE/2);
					CompareFlag = DHL_CompareBuffer(UpdateCodeData,CompareaData,STM_SECTOR_SIZE/2);
					if(CompareFlag == 1)
					{
						addrSave+= STM_SECTOR_SIZE;
						m_ReceiveDataCurNum=0;
						break;
					}
				}
			}			 
		}
		else if((m_IAPDatePackageTotalSize - m_SerialRecvBuffer[2]) <= m_IAPDatePackageTotalSize % (STM_SECTOR_SIZE/128))//最后一页
		{
			memcpy(&m_SerialRecvTransfer[0], &m_SerialRecvBuffer[6], Re_MAX_PARAM_LENGTH-7);	
			for(i=0; i<128; i+=2)
			{
				m_ReceiveCodeDataU16= (((u16)m_SerialRecvTransfer[i+1])<<8) + ((u16)m_SerialRecvTransfer[i]);
				UpdateCodeData[m_ReceiveDataCurNum] = m_ReceiveCodeDataU16;
				m_ReceiveDataCurNum++;
			}	
			if(m_IAPDatePackageTotalSize - 1 == m_SerialRecvBuffer[2])
			{
				for(i=0; i<Rewrite; i++)
				{
					DHL_STMFlash_Write(addrSave,UpdateCodeData, m_ReceiveDataCurNum);
					DHL_STMFlash_Read(addrSave, CompareaData, m_ReceiveDataCurNum);
					CompareFlag = DHL_CompareBuffer(UpdateCodeData, CompareaData, m_ReceiveDataCurNum);
					if(CompareFlag ==1 )
					{																			
						m_finish = 1;	
						//计算扇区
						if(m_IAPDatePackageTotalSize % (STM_SECTOR_SIZE / 128))
							SectorNum = m_IAPDatePackageTotalSize / (STM_SECTOR_SIZE / 128) + 1;
						else 
							SectorNum = m_IAPDatePackageTotalSize / (STM_SECTOR_SIZE / 128);
						break;
					}
				}
			}								
		}
		//-----------串口回复--------------
		DFL_SerialSend(m_SerialRecvBuffer[Re_MAX_PARAM_LENGTH-1], m_SerialRecvBuffer[2]);		
	}
	else if(m_SerialRecvBuffer[0] == 0x53 && m_SerialRecvBuffer[1] == 0x53)
	{
//--------------------------------------重启芯片后进入IAP---------------------------
		if(m_SerialRecvBuffer[2] == 0xF5 && m_SerialRecvBuffer[6] == 0xF5) 
		{
			DFL_SerialSend(0x11,0x11);		   
		}		
//-------------------------------------------更新覆盖-------------------------------
		else if (m_SerialRecvBuffer[2] == 0xF4 && m_SerialRecvBuffer[6] == 0xF4)
		{			
			if(m_finish)
			{
				FLASH_Unlock();	 //解锁
				DHL_STMFlash_Erase(APPLICATION_PROGRAM_ADDRESS, SectorNum + 2); //由于SectorNum必须发生在数据传输后面
				FLASH_Lock();	
			
				addrSave = STM32_FLASH_BASE + (STM32_FLASH_SIZE - BACKUP_CODE_CACHE_SIZE) * 1024;
				
				for(i=0;i<SectorNum;i++)
				{
					DHL_STMFlash_Read(addrSave, UpdateCodeData, STM_SECTOR_SIZE/2);
					DHL_STMFlash_Write(addrCur,UpdateCodeData, STM_SECTOR_SIZE/2);
					
					DHL_STMFlash_Read(addrCur, CompareaData, STM_SECTOR_SIZE/2);
					CompareFlag = DHL_CompareBuffer(UpdateCodeData, CompareaData, STM_SECTOR_SIZE/2);
					if(CompareFlag != 1)
					{
						DFL_SerialSend(0x12,0x12);//写失败
						continue;
					}					
					DFL_SerialSend(0x11,SectorNum);	//回复
									
					addrSave+= STM_SECTOR_SIZE;
					addrCur+= STM_SECTOR_SIZE;										
				}

			}			
			else
			{
				DFL_SerialSend(0x12,0x12);//写失败
//				while(1)
//				{
//					DHL_STMFlash_Read(addrSave, UpdateCodeData, STM_SECTOR_SIZE/2);
//					for(i = 0; i < STM_SECTOR_SIZE/2; i++)  //校验数据是否为0xffff,检测10个半字
//					{
//						if(UpdateCodeData[i]!=0XFFFF)
//						{
//							break;
//						}
//					}
//					if(i<STM_SECTOR_SIZE/2)
//					{
//						for(i=0;i<Rewrite;i++)
//						{
//							DHL_STMFlash_Write(addrCur,UpdateCodeData,STM_SECTOR_SIZE/2);
//							DHL_STMFlash_Read(addrCur, CompareaData,STM_SECTOR_SIZE/2);
//							CompareFlag=DHL_CompareBuffer(UpdateCodeData,CompareaData,STM_SECTOR_SIZE/2);
//							if(CompareFlag==1)
//							{
//								DFL_SerialSend(0x11,SectorNum);//回复
//								
//								addrSave+= STM_SECTOR_SIZE; 
//								addrCur+= STM_SECTOR_SIZE;
//								SectorNum++;	
//								break;								
//							}
//							else if(i==2&&CompareFlag!=1){
//								DFL_SerialSend(0x12,0x12);//写失败
//							}
//						}							
//					}
//					else
//					{
//						break;
//					}
//				}
			}
			AFL_Jump2App();	 
		}			
	}
*/
}

///////////Ymodem-transmission//////////////////////////////////////////////////////
#define YMODEM_DATA_LEN	128

/**
 * @bieaf CRC-16 校验
 *
 * @param addr 开始地址
 * @param num   长度
 * @param num   CRC
 * @return crc  返回CRC的值
 */
#define POLY        0x1021  
uint16_t crc16(unsigned char *addr, int num, uint16_t crc)  
{  
    int i;  
    for (; num > 0; num--)					/* Step through bytes in memory */  
    {  
        crc = crc ^ (*addr++ << 8);			/* Fetch byte from memory, XOR into CRC top byte*/  
        for (i = 0; i < 8; i++)				/* Prepare to rotate 8 bits */  
        {
            if (crc & 0x8000)				/* b15 is set... */  
                crc = (crc << 1) ^ POLY;  	/* rotate and XOR with polynomic */  
            else                          	/* b15 is clear... */  
                crc <<= 1;					/* just rotate */  
        }									/* Loop for 8 bits */  
        crc &= 0xFFFF;						/* Ensure CRC remains 16-bit value */  
    }										/* Loop until num=0 */  
    return(crc);							/* Return updated CRC */  
}



/**
 * @bieaf 获取数据包的类型, 顺便进行校验
 *
 * @param buf 开始地址
 * @param len 长度
 * @return 
 */
unsigned char Check_CRC(unsigned char* buf, int len)
{
	unsigned short crc = 0;
	
	/* 进行CRC校验 */
	if((buf[0]==0x00)&&(len >= YMODEM_DATA_LEN+5))  //YMODEM_DATA_LEN=128
	{
		crc = crc16(buf+3, YMODEM_DATA_LEN, crc);  
		if(crc != (buf[YMODEM_DATA_LEN+3]<<8|buf[YMODEM_DATA_LEN+4]))
		{
			return 0;///< 没通过校验
		}
		
		/* 通过校验 */
		return 1;
	}
	return 0;
}



/* 设置升级的步骤 */
static enum UPDATE_STATE update_state = TO_START;
void Set_state(enum UPDATE_STATE state)
{
	update_state = state;
}


/* 查询升级的步骤 */
uint8_t Get_state(void)
{
	return update_state;
}
void delay_ms(uint32_t time)
{
	/*uint32_t target_ticks = g_SysTick+time;
	while(target_ticks < g_SysTick) {
		int i = 1;
	}*/
	u16 i=0;  
  while(time--)
  {
    i=12000;  //????
    while(i--) ;    
  }
}
/* 发送指令 */
void send_command(uint8_t command)
{
	Dma_send_data(&command, 1);
	delay_ms(3); 
	//HAL_UART_Transmit(&huart2, (uint8_t *)&command,1, 0xFFFF);
	//HAL_Delay(10);  
}


uint8_t temp_buf[256] = {0};
uint8_t temp_len = 0;

/**
 * @bieaf YModem升级
 *
 * @param none
 * @return none
 */
void ymodem_fun(void)
{
	static uint8_t data_state = 0;
	int i;
	if(Get_state()==TO_START)
	{
		send_command(CCC);
		delay_ms(1000);
	}
	if(Rx_Flag)    	// Receive flag
	{
		Rx_Flag=0;	// clean flag
				
		/* 拷贝 */
		temp_len = Rx_Len;
		for(i = 0; i < temp_len; i++)
		{
			temp_buf[i] = m_SerialRecvBuffer[i];
		}
		
		switch(temp_buf[0])
		{
			case SOH:///<数据包开始
			{
				//static unsigned int app2_size = 0;
				if(Check_CRC(temp_buf, temp_len)==1)///< 通过CRC16校验
				{					
					if((Get_state()==TO_START)&&(temp_buf[1] == 0x00)&&(temp_buf[2] == (unsigned char)(~temp_buf[1])))///< 开始
					{
						printf("> Receive start...\r\n");

						Set_state(TO_RECEIVE_DATA);
						data_state = 0x01;	//init data-index					
						send_command(ACK);
						send_command(CCC);

						/* 擦除App2 */							
						DHL_STMFlash_Erase(APPLICATION_UPDCODE_ADDRESS, BACKUP_CODE_CACHE_SIZE/2);
						last_upd_ticks = g_SysTick;
					}
					else if((Get_state()==TO_RECEIVE_END)&&(temp_buf[1] == 0x00)&&(temp_buf[2] == (unsigned char)(~temp_buf[1])))///< 结束
					{
						printf("> Receive end...\r\n");
						CompareFlag = 1;  //ok, if not write to flash
						if(m_ReceiveDataCurNum > 0)		//LAST页就写 
						{
							for (i=m_ReceiveDataCurNum; i<STM_SECTOR_SIZE/2; i++) {
								UpdateCodeData[i] = 0xffff;
							}
							for(i=0; i<Rewrite; i++)
							{						
								DHL_STMFlash_Write(addrSave,UpdateCodeData,STM_SECTOR_SIZE/2);	
								DHL_STMFlash_Read(addrSave, CompareaData,STM_SECTOR_SIZE/2);
								CompareFlag = DHL_CompareBuffer(UpdateCodeData,CompareaData,STM_SECTOR_SIZE/2);
								if(CompareFlag == 1)  //write ok
								{
									m_ReceiveDataCurNum=0;
									break;
								}
							}
						}			 
						if(CompareFlag == 1) {  //write ok
							AFL_Write_StartMode(Startup_Update);						
							Set_state(TO_START);
							send_command(ACK);
							//System_SoftReset();  //system reset 
							last_upd_ticks = g_SysTick;
						}
					}					
					else if((Get_state()==TO_RECEIVE_DATA)&&(temp_buf[1] == data_state)&&(temp_buf[2] == (unsigned char)(~temp_buf[1])))///< 接收数据
					{
						printf("> Receive data bag:%d byte\r\n",data_state * YMODEM_DATA_LEN);  //YMODEM_DATA_LEN=128
						for(i=0; i<YMODEM_DATA_LEN; i+=2)
						{
							m_ReceiveCodeDataU16= (((u16)temp_buf[i+4])<<8) + ((u16)m_SerialRecvTransfer[i+3]);
							UpdateCodeData[m_ReceiveDataCurNum++] = m_ReceiveCodeDataU16;
						}	
						CompareFlag = 1;  //ok, if not write to flash
						if(m_ReceiveDataCurNum == STM_SECTOR_SIZE/2)		//满一页就写 
						{
							for(i=0; i<Rewrite; i++)
							{						
								DHL_STMFlash_Write(addrSave,UpdateCodeData,STM_SECTOR_SIZE/2);	
								DHL_STMFlash_Read(addrSave, CompareaData,STM_SECTOR_SIZE/2);
								CompareFlag = DHL_CompareBuffer(UpdateCodeData,CompareaData,STM_SECTOR_SIZE/2);
								if(CompareFlag == 1)  //write ok
								{
									addrSave+= STM_SECTOR_SIZE;
									m_ReceiveDataCurNum=0;
									break;
								}
							}
						}			 
						/* 烧录程序 */
						//WriteFlash((Application_2_Addr + (data_state-1) * 128), (uint32_t *)(&temp_buf[3]), 32);
						if(CompareFlag == 1) { // write ok
							data_state++;						
							send_command(ACK);		
						}
					}
				}
				else
				{
					printf("> Notpass crc\r\n");
				}
				
			}break;
			case EOT://数据包 end of transmission 
			{
				if(Get_state()==TO_RECEIVE_DATA)
				{
					printf("> Receive EOT1...\r\n");
					
					Set_state(TO_RECEIVE_EOT2);					
					send_command(NACK);
				}
				else if(Get_state()==TO_RECEIVE_EOT2)
				{
					printf("> Receive EOT2...\r\n");
					
					Set_state(TO_RECEIVE_END);					
					send_command(ACK);
					send_command(CCC);
				}
				else
				{
					printf("> Receive EOT, But error...\r\n");
				}
			}break;	
		}
	}
}
/******************* (C) COPYRIGHT 2017 LECOOAI *****END OF FILE****/