/*
 * launcher_fun.c
 *
 *  Created on: Jul 28, 2025
 *      Author: cc
 */
#include "includes.h"
#include <string.h>

G_SYS_FEATURE_T g_app_feature;          //SPI Flash APP特征区
G_SYS_FEATURE_T g_mcu_app_feature;      //MCU Flash APP特征区

G_SYS_FEATURE_T g_update_flag;          //升级标志位
UPDATE_RECORD_T g_update_recode;        //升级信息

uint8_t g_jump_flag = 0;            //跳转标志位
uint32_t g_Boot_Tick = 0;           //Boot时间戳       单位：ms
uint32_t g_Boot_Time= 30000;            //Boot时间            单位：ms

/*******************************************************************************
* Function Name  : Boot_Time_Refresh
* Description    : Boot时间戳更新
*******************************************************************************/
void Boot_Time_Refresh(void)
{
    g_Boot_Tick = SysTick_1ms;
}

/*******************************************************************************
* Function Name  : Boot_Timeout_Task
* Description    : Boot超时任务
*******************************************************************************/
void Boot_Timeout_Task(void)
{
    if(SysTick_1ms - g_Boot_Tick >= g_Boot_Time)
    {
        while(1);   //执行看门狗复位
    }
}

/*******************************************************************************
* Function Name  : SPI_FLASH_APP_Data_Erase
* Description    : 外部Flash APP空间擦除
*       APP空间大小 Size: 0x00070000    地址范围：0x00000000 ~ 0x0006FFFF
*******************************************************************************/
void SPI_FLASH_APP_Data_Erase(void)
{
    Flash_Erase_Page(0);        //擦除APP特征区
    for(uint8_t i = 1;i < 16;i++)
    {
        WDT_Feed();

        Flash_Erase_Sector(i);
    }
    for(uint8_t i = 1;i < 7;i++)
    {
        WDT_Feed();

        Flash_Erase_Block(i);
    }
}

/*******************************************************************************
* Function Name  : SPI_FLASH_Logic_File_Erase
* Description    : 外部Flash 配置文件空间擦除
*       APP空间大小 Size: 0x00090000    地址范围：0x00070000 ~ 0x000FFFFF
*******************************************************************************/
void SPI_FLASH_Logic_File_Erase(void)
{
    for(uint8_t i = 7;i < 16;i++)
    {
        WDT_Feed();

        Flash_Erase_Block(i);
    }
}

/*******************************************************************************
* Function Name  : CRC16_Check
* Description    : CRC16校验算法
*******************************************************************************/
uint16_t CRC16_Check(uint8_t * aStr, uint16_t len)
{
    uint16_t xda , xdapoly ;
    uint16_t i, j, xdabit ;
    xda = 0xFFFF ;
    xdapoly = 0xA001 ;  // (X**16 + X**15 + X**2 + 1)
    for (i = 0; i < len; i++)
    {
        xda ^= aStr[i] ;
        for (j = 0; j < 8; j++)
        {
            xdabit = (unsigned char)(xda & 0x01) ;
            xda >>= 1 ;
            if ( xdabit ) xda ^= xdapoly ;
        }
    }
    return xda;
}


/*******************************************************************************
* Function Name  : Boot_Comm_FillReplyPack
* Description    : Boot通讯协议回复数据打包函数
*******************************************************************************/
void Boot_Comm_FillReplyPack(UART_t *g_rev)
{
    uint16_t data_len = g_rev->ackLen + BCOMM_FMT_PARAM;

    g_rev->ackBuffer[BCOMM_FMT_TXAddr] = g_mcu_dev.dev_addr;
    g_rev->ackBuffer[BCOMM_FMT_SN] = g_rev->sn;
    g_rev->ackBuffer[BCOMM_FMT_TYPE] = g_mcu_dev.dev_type;
    g_rev->ackBuffer[BCOMM_FMT_RXAddr] = g_rev->pc_addr;

    g_rev->ackBuffer[BCOMM_FMT_CMD] = g_rev->cmd;
    g_rev->ackBuffer[BCOMM_FMT_LEN_L] = data_len & 0xFF;
    g_rev->ackBuffer[BCOMM_FMT_LEN_H] = (data_len >> 8) & 0xFF;

    g_rev->ackBuffer[BCOMM_FMT_CKS] = 0;

    g_rev->ackBuffer[BCOMM_FMT_CKS] = Data_CheckSum(g_rev->ackBuffer, data_len);

#if DBG_LOG_EN
    Dbg_Print_Buff(DBG_BIT_SYS_STATUS,"ACKBuff ",g_rev->ackBuffer,data_len);
#endif


    Uartx_Add_Data_To_SendBuff(g_rev,g_rev->ackBuffer,data_len,0x01,500,50);

}

uint8_t Launcher_Uart_Upgrade_Process(UART_t *g_rev)
{
    uint8_t deal_flag = 0,group_flag = 0,reply_flag = 0;
    uint16_t crcNumIndex = 0,crcResultFlag = 0;
    uint32_t temp_val = 0,temp_val_2 = 0;

    /*拷贝串口缓冲区中的数据内容 */
    __disable_irq();
    memcpy(g_rev->deal_buff,g_rev->RecvBuffer,g_rev->RecvLen);
    g_rev->deal_len = g_rev->RecvLen;
    g_rev->RecvLen = 0;
    memset(g_rev->RecvBuffer,0,USART_BUFFER_SIZE);

    g_rev->Receiving = 0x00;    //接收结束
    g_rev->CommBusy &= ~(UART_COMMBUSY_RECV_Flag);  //清除接收标志位

    __enable_irq();

//    DBG_SYS_Printf("Len %d \r\n",g_rev->deal_len);
//    Dbg_Print_Buff(DBG_BIT_SYS_STATUS,"UARTx_Buff:",g_rev->deal_buff,g_rev->deal_len);

    temp_val = g_rev->deal_buff[BCOMM_FMT_LEN_H];
    temp_val <<= 8;
    temp_val |= g_rev->deal_buff[BCOMM_FMT_LEN_L];

    if(temp_val != g_rev->deal_len)
    {
        DBG_SYS_Printf("Len Fail %d - %d\r\n",g_rev->deal_len,temp_val);
        Dbg_Print_Buff(DBG_BIT_SYS_STATUS,"UARTx_Buff:",g_rev->deal_buff,g_rev->deal_len);
        return 0x01;
    }

    if(Data_CheckSum(g_rev->deal_buff,g_rev->deal_len) != 0)   {
        DBG_SYS_Printf("Boot_Comm_CheckSum Fail:%x ",Data_CheckSum(g_rev->deal_buff,g_rev->deal_len));
        return 0x02;
    }

    if( (g_rev->deal_buff[BCOMM_FMT_SN] & 0x80) == 0x80){
        //群发标志位
        group_flag = 0x01;
        if( (g_rev->deal_buff[BCOMM_FMT_SN] & 0x0F) !=  g_rev->sn){
            deal_flag = 0x01;

            DBG_SYS_Printf("Group Data SN Disaffinity,Processing Data");
        }else {
            deal_flag = 0x00;

            DBG_SYS_Printf("Group Data SN The Same,No Processing Data");
        }
    }else {
        //单发标志位
        group_flag = 0x00;
        if( (g_rev->deal_buff[BCOMM_FMT_SN] & 0x0F) !=  g_rev->sn){
            //包序号不太相同，需要处理
            DBG_SYS_Printf("Single Data SN Disaffinity,Processing Data");

            deal_flag = 0x01;
            reply_flag = 0x01;
        }else if( (g_rev->deal_buff[BCOMM_FMT_SN] & 0x40) == 0x40 ){
            //包序号相同，重发标志位置位，不处理，但是需要回复数据
            deal_flag = 0x00;
            reply_flag = 0x01;

            DBG_SYS_Printf("Single Data SN The Same,No Processing Data");
        }
    }

    /*判断类型是否相同，且不是广播类型*/
    if( (g_rev->deal_buff[BCOMM_FMT_TYPE] != g_mcu_dev.dev_type) && (g_rev->deal_buff[BCOMM_FMT_TYPE] != 0xFF) ){
        DBG_SYS_Printf("Boot_Comm_RecvType %d - %d ",g_mcu_dev.dev_type,g_rev->deal_buff[BCOMM_FMT_TYPE]);
        return 0x03;
    }
    /*判断是否广播类型与广播地址*/
    if( (g_rev->deal_buff[BCOMM_FMT_RXAddr] != g_mcu_dev.dev_addr) && (g_rev->deal_buff[BCOMM_FMT_RXAddr] != 0xFF) ){
        DBG_SYS_Printf("Boot_Comm_RecvAddr %d - %d ",g_mcu_dev.dev_addr,g_rev->deal_buff[BCOMM_FMT_RXAddr]);
        return 0x04;
    }

    Boot_Time_Refresh();
    g_rev->pc_addr = g_rev->deal_buff[BCOMM_FMT_TXAddr];
    g_rev->sn = g_rev->deal_buff[BCOMM_FMT_SN] & 0x0F;
    g_rev->cmd = g_rev->deal_buff[BCOMM_FMT_CMD];

    switch(g_rev->cmd)
    {
        case BCOMM_CMD_Handshake:

            if( ( deal_flag == 0x01 ) && ( g_rev->deal_len >= ( BCOMM_FMT_PARAM + 4 ) ) ) {
                /*设置Boot 超时时间  单位：S*/
                temp_val = g_rev->deal_buff[BCOMM_FMT_PARAM + 1];
                temp_val <<= 8;
                temp_val |= g_rev->deal_buff[BCOMM_FMT_PARAM];

                if(temp_val != g_Boot_Time)
                {
                    g_Boot_Time = temp_val;
                    if(g_Boot_Time < 10)    g_Boot_Time = 10;
                    g_Boot_Time = g_Boot_Time * 1000;
                }

                /*回复数据的有效期*/
                temp_val = g_rev->deal_buff[BCOMM_FMT_PARAM + 3];
                temp_val <<= 8;
                temp_val |= g_rev->deal_buff[BCOMM_FMT_PARAM + 2];
                g_rev->ackValidity = temp_val;
            }

            //握手命令 - 需要回复的数据，正常回复
            if(reply_flag != 0x01)  break;      //不回复，直接退出
            g_rev->ackBuffer[BCOMM_FMT_PARAM] = Project_Area;                       //当前处于Bootload区域  0x01：Boot;0x02：APP
            g_rev->ackBuffer[BCOMM_FMT_PARAM + 1] = g_mcu_dev.dev_boot_ver;         //Boot 软件版本号
            g_rev->ackBuffer[BCOMM_FMT_PARAM + 2] = g_mcu_dev.dev_app_ver;          //APP  软件版本号
            //MCU UID
            g_rev->ackBuffer[BCOMM_FMT_PARAM + 3] = 0x06;           //CH564 以MAC地址作为唯一ID 长度6Byte

            GetMACAddress(&g_rev->ackBuffer[BCOMM_FMT_PARAM + 4]);

            //机型编号 - 32Byte
            g_rev->ackBuffer[BCOMM_FMT_PARAM + 10] = g_mcu_dev.dev_name_len;
            g_rev->ackLen = 11;
            for(uint8_t i=0;i<g_mcu_dev.dev_name_len;i++){
                g_rev->ackBuffer[BCOMM_FMT_PARAM + i + 11] = g_mcu_dev.dev_name[i];
                g_rev->ackLen++;
            }

            break;
        case BCOMM_CMD_Jump:                                 //跳转命令
            if(deal_flag != 0x01)   break;  //不处理直接退出

            if(g_rev->deal_buff[BCOMM_FMT_PARAM] == 0x02){
                /*跳转至APP区域*/
                g_Boot_Time = 200;
                g_Boot_Tick = SysTick_1ms;
                g_jump_flag = 0x01;             //通过软件超时 - 全局复位
                g_rev->ackBuffer[BCOMM_FMT_PARAM] = BCOMM_CMD_ReplySUCC;
            }else {
                /*参数错误*/

                DBG_SYS_Printf("ERR:Jump_boot");
                g_rev->ackBuffer[BCOMM_FMT_PARAM] = BCOMM_CMD_ReplyFAIL;
            }

            g_rev->ackLen = 1;
            break;
        case BCOMM_CMD_SetInfo:                                 //设置参数
            if(deal_flag != 0x01)   break;  //不处理直接退出

            if(g_rev->deal_len < (BCOMM_FMT_PARAM + 4) )   {
                DBG_SYS_Printf("BCOMM_CMD_SetInfo Para Error ");
                break;
            }

            DBG_SYS_Printf("BCOMM_CMD_SetInfo Proecessing ");

            /*设置波特率参数*/
            temp_val = g_rev->deal_buff[BCOMM_FMT_PARAM + 1];
            temp_val <<= 8;
            temp_val |= g_rev->deal_buff[BCOMM_FMT_PARAM];
            temp_val *= 100;

            /*设置Boot 超时时间*/
            g_Boot_Time = g_rev->deal_buff[BCOMM_FMT_PARAM + 3];
            g_Boot_Time <<= 8;
            g_Boot_Time |= g_rev->deal_buff[BCOMM_FMT_PARAM + 2];
            if(g_Boot_Time < 10)     g_Boot_Time = 10;
            g_Boot_Time = g_Boot_Time  * 1000;

            DBG_SYS_Printf("bootTimeout: %d",g_Boot_Time);

            if(g_rev->CommBaud != temp_val)
            {
                g_rev->ChangeBaudFlag = 0x01;
                g_rev->CommBaud = temp_val;
                DBG_SYS_Printf("BaudSet: %d",temp_val);
            }else {
                DBG_SYS_Printf("Baud Not Change: %d",temp_val);
            }


            g_rev->ackBuffer[BCOMM_FMT_PARAM] = BCOMM_CMD_ReplySUCC;
            g_rev->ackLen = 1;

            break;
        case BCOMM_CMD_WriteFlash:                              //写Flash
            if(deal_flag != 0x01)   break;  //不处理直接退出

            if( g_rev->deal_len < (BCOMM_FMT_PARAM + 6) )   {
                DBG_SYS_Printf("BCOMM_CMD_WriteFlash Para Error ");
                break;
            }

            DBG_SYS_Printf("BCOMM_CMD_WriteFlash Proecessing ");

            /*写入Flash地址 */
            temp_val = g_rev->deal_buff[BCOMM_FMT_PARAM + 3];
            temp_val <<= 8;
            temp_val |= g_rev->deal_buff[BCOMM_FMT_PARAM + 2];
            temp_val <<= 8;
            temp_val |= g_rev->deal_buff[BCOMM_FMT_PARAM + 1];
            temp_val <<= 8;
            temp_val |= g_rev->deal_buff[BCOMM_FMT_PARAM];

            /*写入Flash长度 */
            temp_val_2 = g_rev->deal_buff[BCOMM_FMT_PARAM + 5];
            temp_val_2 <<= 8;
            temp_val_2 |= g_rev->deal_buff[BCOMM_FMT_PARAM + 4];

            DBG_SYS_Printf("WAddr: 0x%x Len:%d",temp_val,temp_val_2);

            if (temp_val_2 == ( g_rev->deal_len - BCOMM_FMT_PARAM - 6 )){
                /*Flash 数据写入*/

                //g_rev->ackBuffer[BCOMM_FMT_PARAM] = MCU_APP_Flash_Write(&g_rev->deal_buff[BCOMM_FMT_PARAM + 6],temp_val_2,temp_val);

                Flash_Write_NoCheck(&g_rev->deal_buff[BCOMM_FMT_PARAM + 6],temp_val_2,temp_val);

                Flash_Read(g_read_buff, temp_val_2,temp_val);
                Dbg_Print_Buff(DBG_BIT_SYS_STATUS,"App CRC BUFF:",g_read_buff,temp_val_2);

                g_rev->ackBuffer[BCOMM_FMT_PARAM] = BCOMM_CMD_ReplySUCC;
            }else {
                /*写入Flash 不在地址范围内 */
                g_rev->ackBuffer[BCOMM_FMT_PARAM] = BCOMM_CMD_ReplyFAIL;
            }
            g_rev->ackLen = 1;
            break;
        case BCOMM_CMD_ReadFlash:                               //读取Flash
            if(deal_flag != 0x01)   break;  //不处理直接退出

            if( g_rev->deal_len < (BCOMM_FMT_PARAM + 6) )   {
                DBG_SYS_Printf("BCOMM_CMD_ReadFlash Para Error ");
                break;
            }

            DBG_SYS_Printf("BCOMM_CMD_ReadFlash Proecessing ");

            /*读取Flash地址 */
            temp_val = g_rev->deal_buff[BCOMM_FMT_PARAM + 3];
            temp_val <<= 8;
            temp_val |= g_rev->deal_buff[BCOMM_FMT_PARAM + 2];
            temp_val <<= 8;
            temp_val |= g_rev->deal_buff[BCOMM_FMT_PARAM + 1];
            temp_val <<= 8;
            temp_val |= g_rev->deal_buff[BCOMM_FMT_PARAM];

            /*读取Flash长度 */
            temp_val_2 = g_rev->deal_buff[BCOMM_FMT_PARAM + 5];
            temp_val_2 <<= 8;
            temp_val_2 |= g_rev->deal_buff[BCOMM_FMT_PARAM + 4];

            if(temp_val_2 > BCOMM_ParaSize) temp_val_2 = BCOMM_ParaSize;      //参数最长，不能超过ACK BUFF大小

            g_rev->ackBuffer[BCOMM_FMT_PARAM] = MCU_APP_Flash_Read(&g_rev->ackBuffer[BCOMM_FMT_PARAM + 1],temp_val_2,temp_val);
            if(g_rev->ackBuffer[BCOMM_FMT_PARAM] == BCOMM_CMD_ReplySUCC)
            {
                g_rev->ackLen = temp_val_2 + 1;
            }else {
                g_rev->ackLen = 1;
            }
            break;
        case BCOMM_CMD_EraseFlash:                               //擦除Flash
            if(deal_flag != 0x01)   break;  //不处理直接退出

            if( g_rev->deal_len < (BCOMM_FMT_PARAM + 1) )   {
                DBG_SYS_Printf("BCOMM_CMD_ReadFlash Para Error ");
                break;
            }
            DBG_SYS_Printf("BCOMM_CMD_EraseFlash Proecessing ");

            if(g_rev->deal_buff[BCOMM_FMT_PARAM] == 0x01){
                /*擦除APP Flash 指定区域*/
                if( g_rev->deal_len < (BCOMM_FMT_PARAM + 7) )   {
                    DBG_SYS_Printf("BCOMM_CMD_EraseFlash Para Error ");
                    break;
                }

                /*擦除Flash地址 */
                temp_val = g_rev->deal_buff[BCOMM_FMT_PARAM + 4];
                temp_val <<= 8;
                temp_val |= g_rev->deal_buff[BCOMM_FMT_PARAM + 3];
                temp_val <<= 8;
                temp_val |= g_rev->deal_buff[BCOMM_FMT_PARAM + 2];
                temp_val <<= 8;
                temp_val |= g_rev->deal_buff[BCOMM_FMT_PARAM + 1];

                /*擦除Flash 长度*/
                temp_val_2 = g_rev->deal_buff[BCOMM_FMT_PARAM + 6];
                temp_val_2 <<= 8;
                temp_val_2 |= g_rev->deal_buff[BCOMM_FMT_PARAM + 5];

                if( (MCU_APP_Flash_Start_Addr <= temp_val) && ( (temp_val + temp_val_2) < MCU_APP_Flash_End_Addr ) ){

                    DBG_SYS_Printf("EraseFlash Addr:%x Len:%d ",temp_val,temp_val_2);

                    temp_val = temp_val - (temp_val % MCU_APP_Flash_PageSize);
                    for(uint32_t i = temp_val;i<(temp_val + temp_val_2) ;i+=MCU_APP_Flash_PageSize){

                        DBG_SYS_Printf("PageErase Addr:%x ",i);

                        //FLASH_ROMA_ERASE(i,MCU_APP_Flash_PageSize);
                        //Flash_Erase_Sector(i);
                    }

                    g_rev->ackBuffer[BCOMM_FMT_PARAM] = BCOMM_CMD_ReplySUCC;
                    g_rev->ackLen = 1;
                }else {
                    /*写入Flash 不在地址范围内 */
                    g_rev->ackBuffer[BCOMM_FMT_PARAM] = BCOMM_CMD_ReplyFAIL;
                    g_rev->ackLen = 1;
                }

            }else if(g_rev->deal_buff[BCOMM_FMT_PARAM] == 0x02){
                /*擦除全部APP Flash 同时也有APP 特征区*/
                SPI_FLASH_APP_Data_Erase();

                g_rev->ackBuffer[BCOMM_FMT_PARAM] = BCOMM_CMD_ReplySUCC;
                g_rev->ackLen = 1;
            }else {
                g_rev->ackBuffer[BCOMM_FMT_PARAM] = BCOMM_CMD_ReplyFAIL;
                g_rev->ackLen = 1;
            }
            break;
        case BCOMM_CMD_WriteEEPROM:                             //写EEPROM
            if(deal_flag != 0x01)   break;  //不处理直接退出

            if( g_rev->deal_len < (BCOMM_FMT_PARAM + 6) )   {
                DBG_SYS_Printf("BCOMM_CMD_WriteEEPROM Para Error ");
                break;
            }

            DBG_SYS_Printf("BCOMM_CMD_WriteEEPROM Proecessing ");

            /*写入Flash地址 */
            temp_val = g_rev->deal_buff[BCOMM_FMT_PARAM + 3];
            temp_val <<= 8;
            temp_val |= g_rev->deal_buff[BCOMM_FMT_PARAM + 2];
            temp_val <<= 8;
            temp_val |= g_rev->deal_buff[BCOMM_FMT_PARAM + 1];
            temp_val <<= 8;
            temp_val |= g_rev->deal_buff[BCOMM_FMT_PARAM];

            /*写入Flash长度 */
            temp_val_2 = g_rev->deal_buff[BCOMM_FMT_PARAM + 5];
            temp_val_2 <<= 8;
            temp_val_2 |= g_rev->deal_buff[BCOMM_FMT_PARAM + 4];

            DBG_SYS_Printf("WAddr: 0x%x Len:%d",temp_val,temp_val_2);

            if (temp_val_2 == ( g_rev->deal_len - BCOMM_FMT_PARAM - 6 )){
                /*Flash 数据写入*/
                g_rev->ackBuffer[BCOMM_FMT_PARAM] = MCU_EEPROM_Write(&g_rev->deal_buff[BCOMM_FMT_PARAM + 6],temp_val_2,temp_val);
            }else {
                /*写入Flash 不在地址范围内 */
                g_rev->ackBuffer[BCOMM_FMT_PARAM] = BCOMM_CMD_ReplyFAIL;
            }
            g_rev->ackLen = 1;

            break;
        case BCOMM_CMD_ReadEEPROM:                             //写EEPROM
            if(deal_flag != 0x01)   break;  //不处理直接退出

            if( g_rev->deal_len < (BCOMM_FMT_PARAM + 6) )   {
                DBG_SYS_Printf("BCOMM_CMD_ReadFlash Para Error ");
                break;
            }

            DBG_SYS_Printf("BCOMM_CMD_ReadFlash Proecessing ");

            /*读取Flash地址 */
            temp_val = g_rev->deal_buff[BCOMM_FMT_PARAM + 3];
            temp_val <<= 8;
            temp_val |= g_rev->deal_buff[BCOMM_FMT_PARAM + 2];
            temp_val <<= 8;
            temp_val |= g_rev->deal_buff[BCOMM_FMT_PARAM + 1];
            temp_val <<= 8;
            temp_val |= g_rev->deal_buff[BCOMM_FMT_PARAM];

            /*读取Flash长度 */
            temp_val_2 = g_rev->deal_buff[BCOMM_FMT_PARAM + 5];
            temp_val_2 <<= 8;
            temp_val_2 |= g_rev->deal_buff[BCOMM_FMT_PARAM + 4];

            if(temp_val_2 > BCOMM_ParaSize) temp_val_2 = BCOMM_ParaSize;      //参数最长，不能超过ACK BUFF大小

            g_rev->ackBuffer[BCOMM_FMT_PARAM] = MCU_APP_Flash_Read(&g_rev->ackBuffer[BCOMM_FMT_PARAM + 1],temp_val_2,temp_val);
            if(g_rev->ackBuffer[BCOMM_FMT_PARAM] == BCOMM_CMD_ReplySUCC)
            {
                g_rev->ackLen = temp_val_2 + 1;
            }else {
                g_rev->ackLen = 1;
            }
            break;
        case BCOMM_CMD_EraseEEPROM:                             //擦除EEPROM
            if(deal_flag != 0x01)   break;  //不处理直接退出

            if( g_rev->deal_len < (BCOMM_FMT_PARAM + 1) )   {
                DBG_SYS_Printf("BCOMM_CMD_EraseEEPROM Para Error ");
                break;
            }
            DBG_SYS_Printf("BCOMM_CMD_EraseEEPROM Proecessing ");

            if(g_rev->deal_buff[BCOMM_FMT_PARAM] == 0x01){
                /*擦除APP Flash 指定区域*/
                if( g_rev->deal_len < (BCOMM_FMT_PARAM + 7) )   {
                    DBG_SYS_Printf("BCOMM_CMD_EraseEEPROM Para Error ");
                    break;
                }

                /*擦除Flash地址 */
                temp_val = g_rev->deal_buff[BCOMM_FMT_PARAM + 4];
                temp_val <<= 8;
                temp_val |= g_rev->deal_buff[BCOMM_FMT_PARAM + 3];
                temp_val <<= 8;
                temp_val |= g_rev->deal_buff[BCOMM_FMT_PARAM + 2];
                temp_val <<= 8;
                temp_val |= g_rev->deal_buff[BCOMM_FMT_PARAM + 1];

                /*擦除Flash 长度*/
                temp_val_2 = g_rev->deal_buff[BCOMM_FMT_PARAM + 6];
                temp_val_2 <<= 8;
                temp_val_2 |= g_rev->deal_buff[BCOMM_FMT_PARAM + 5];

                if( (MCU_APP_Flash_Start_Addr <= temp_val) && ( (temp_val + temp_val_2) < MCU_APP_Flash_End_Addr ) ){

                    DBG_SYS_Printf("EraseFlash Addr:%x Len:%d ",temp_val,temp_val_2);

                    temp_val = temp_val - (temp_val % MCU_APP_Flash_PageSize);
                    for(uint32_t i = temp_val;i<(temp_val + temp_val_2) ;i+=MCU_APP_Flash_PageSize){

                        DBG_SYS_Printf("PageErase Addr:%x ",i);

                        FLASH_ROMA_ERASE(i,MCU_APP_Flash_PageSize);
                    }

                    g_rev->ackBuffer[BCOMM_FMT_PARAM] = BCOMM_CMD_ReplySUCC;
                    g_rev->ackLen = 1;
                }else {
                    /*写入Flash 不在地址范围内 */
                    g_rev->ackBuffer[BCOMM_FMT_PARAM] = BCOMM_CMD_ReplyFAIL;
                    g_rev->ackLen = 1;
                }

            }else if(g_rev->deal_buff[BCOMM_FMT_PARAM] == 0x02){
                /*擦除全部EEPROM*/
                MCU_EEPROM_ALLErase();

                g_rev->ackBuffer[BCOMM_FMT_PARAM] = BCOMM_CMD_ReplySUCC;
                g_rev->ackLen = 1;
            }else {
                g_rev->ackBuffer[BCOMM_FMT_PARAM] = BCOMM_CMD_ReplyFAIL;
                g_rev->ackLen = 1;
            }
            break;
        case BCOMM_CMD_CheckData:                               //校验
            if(deal_flag != 0x01)   break;  //不处理直接退出

            if( g_rev->deal_len < (BCOMM_FMT_PARAM + 10) )  {

                DBG_SYS_Printf("BCOMM_CMD_CheckData Para Error ");
                break;
            }

            DBG_SYS_Printf("BCOMM_CMD_CheckData Proecessing ");

            memset(&g_app_feature,0,sizeof(G_SYS_FEATURE_T));

            /* 校验CRC 起始地址*/
            g_app_feature.app_start_addr = g_rev->deal_buff[BCOMM_FMT_PARAM + 3];
            g_app_feature.app_start_addr <<= 8;
            g_app_feature.app_start_addr |= g_rev->deal_buff[BCOMM_FMT_PARAM + 2];
            g_app_feature.app_start_addr <<= 8;
            g_app_feature.app_start_addr |= g_rev->deal_buff[BCOMM_FMT_PARAM + 1];
            g_app_feature.app_start_addr <<= 8;
            g_app_feature.app_start_addr |= g_rev->deal_buff[BCOMM_FMT_PARAM];

            /* 校验CRC 结束地址*/
            g_app_feature.app_end_addr = g_rev->deal_buff[BCOMM_FMT_PARAM + 7];
            g_app_feature.app_end_addr <<= 8;
            g_app_feature.app_end_addr |= g_rev->deal_buff[BCOMM_FMT_PARAM + 6];
            g_app_feature.app_end_addr <<= 8;
            g_app_feature.app_end_addr |= g_rev->deal_buff[BCOMM_FMT_PARAM + 5];
            g_app_feature.app_end_addr <<= 8;
            g_app_feature.app_end_addr |= g_rev->deal_buff[BCOMM_FMT_PARAM + 4];

            /* 校验CRC 大小*/
            g_app_feature.app_crc_size = g_rev->deal_buff[BCOMM_FMT_PARAM + 9];
            g_app_feature.app_crc_size <<= 8;
            g_app_feature.app_crc_size |= g_rev->deal_buff[BCOMM_FMT_PARAM + 8];

            DBG_SYS_Printf("App Start_addr :%x ",g_app_feature.app_start_addr);
            DBG_SYS_Printf("App End_addr :%x ",g_app_feature.app_end_addr);
            DBG_SYS_Printf("App CRC Block_Size :%d ",g_app_feature.app_crc_size);

            if( (g_app_feature.app_start_addr >= MCU_APP_Flash_Start_Addr)
                && (g_app_feature.app_end_addr < MCU_APP_Flash_End_Addr)
                && (g_app_feature.app_end_addr > g_app_feature.app_start_addr)
                && (g_app_feature.app_crc_size == MCU_APP_Flash_PageSize) )
            {
                temp_val = g_app_feature.app_end_addr - g_app_feature.app_start_addr;

                DBG_SYS_Printf("App Len :%d ",temp_val);

                if( (temp_val % g_app_feature.app_crc_size ) != 0x00 ){
                    g_app_feature.app_crc_len = ((temp_val / g_app_feature.app_crc_size) + 1) * 2;
                }else {
                    g_app_feature.app_crc_len = (temp_val / g_app_feature.app_crc_size) * 2;
                }

                DBG_SYS_Printf("App CRC BLock:%d ",g_app_feature.app_crc_len);

                /*比对校验的数据包长 对不对 */
                if( (BCOMM_FMT_PARAM + 10 + g_app_feature.app_crc_len ) == g_rev->deal_len ){

                    uint32_t crc_data_len = 0;
                    crcNumIndex = 0;

                    memcpy(g_app_feature.app_crc,&g_rev->deal_buff[BCOMM_FMT_PARAM + 10],(g_rev->deal_len - 10 - BCOMM_FMT_PARAM) );

                    for(uint32_t crc_addr = g_app_feature.app_start_addr; crc_addr < g_app_feature.app_end_addr;crc_addr += g_app_feature.app_crc_size)
                    {
                        WDT_Feed();

                        if( g_app_feature.app_end_addr - crc_addr >= g_app_feature.app_crc_size)    {
                            crc_data_len = g_app_feature.app_crc_size;
                        }else {
                            crc_data_len = g_app_feature.app_end_addr - crc_addr;
                        }

                        memset(g_read_buff,0,sizeof(g_read_buff));

                        if(crc_data_len > 2048)
                        {
                            Flash_Read(g_read_buff,2048,crc_addr);
                            Flash_Read(&g_read_buff[2048],(crc_data_len - 2048),crc_addr+2048);
                        }else {
                            Flash_Read(g_read_buff,crc_data_len,crc_addr);
                        }

                        temp_val = CRC16_Check(g_read_buff,crc_data_len);
                        temp_val_2 = g_app_feature.app_crc[crcNumIndex + 1];
                        temp_val_2 <<= 8;
                        temp_val_2 |= g_app_feature.app_crc[crcNumIndex];

                        //DBG_SYS_Printf("App CRC ADDR:%x %x-%x",crc_addr,temp_val,temp_val_2);
                        //Dbg_Print_Buff(DBG_BIT_SYS_STATUS,"App CRC BUFF:",g_read_buff,crc_data_len);

                        if(temp_val != temp_val_2){
                            /*校验失败 - */

                            g_rev->ackBuffer[BCOMM_FMT_PARAM ] = BCOMM_CMD_ReplyFAIL;
                            g_rev->ackBuffer[BCOMM_FMT_PARAM + 5 + crcResultFlag*4] = ((crc_addr >> 24) & 0xFF);
                            g_rev->ackBuffer[BCOMM_FMT_PARAM + 4 + crcResultFlag*4] = ((crc_addr >> 16) & 0xFF);
                            g_rev->ackBuffer[BCOMM_FMT_PARAM + 3 + crcResultFlag*4] = ((crc_addr >> 8) & 0xFF);
                            g_rev->ackBuffer[BCOMM_FMT_PARAM + 2 + crcResultFlag*4] = (crc_addr & 0xFF);

                            Dbg_Print_Buff(DBG_BIT_SYS_STATUS,"Flash Data:",g_read_buff,crc_data_len);
                            DBG_SYS_Printf("App CRC Fail ADDR:%X %X-%X",crc_addr,temp_val,temp_val_2);

                            crcResultFlag++;
                            if(crcResultFlag >= 20) break;
                        }
                        crcNumIndex += 2;
                    }

                    if(crcResultFlag == 0x00){
                        /*校验成功 - 写入APP 特征区*/
                        g_app_feature.app_flag = App_Procedure_Ready;
                        g_app_feature.crc_check = 0x00;

                        Write_APP_Feature_Info(0x02,&g_app_feature);

                        g_rev->ackBuffer[BCOMM_FMT_PARAM] = BCOMM_CMD_ReplySUCC;
                    }

                    g_rev->ackBuffer[BCOMM_FMT_PARAM + 1] = crcResultFlag;
                    g_rev->ackLen = 2 + crcResultFlag*4;
                }else {
                    /*数据包长不对*/
                    DBG_SYS_Printf("App CRC BLock ERROR:%d %d",temp_val,g_rev->deal_len);

                    g_rev->ackBuffer[BCOMM_FMT_PARAM] = 0x02;
                    g_rev->ackLen = 1;
                }
            }else{

                DBG_SYS_Printf("App CRC Para ERROR");

                g_rev->ackBuffer[BCOMM_FMT_PARAM] = 0x01;
                g_rev->ackLen = 1;
            }
            break;
    }

    /*回复通讯数据*/
    if( (group_flag == 0x00) && (reply_flag == 0x01) )
    {
        Boot_Comm_FillReplyPack(g_rev);
    }

    return 0;
}

/*******************************************************************************
* Function Name  : Read_APP_Feature
* Description    : 读取APP特征区参数
* Return         :
    0：没问题
    1：Flash中APP不正确或错误
    2：MCU APP需要更新
*******************************************************************************/
uint8_t Read_APP_Feature(void)
{
    uint8_t rev = 0;
    uint8_t crcResultFlag = TRUE;
    uint16_t crcNumIndex = 0;
    uint16_t crcVal = 0;
    uint8_t crcValH = 0, crcValL = 0;
    uint32_t crc_data_len = 0;
    uint8_t update_flag = 0;

    memset(&g_app_feature,0,sizeof(G_SYS_FEATURE_T));
    memset(&g_mcu_app_feature,0,sizeof(G_SYS_FEATURE_T));

    /*第一步：先读取外部Flash的APP特征区是否有数据，同时验证APP的合法性*/
    rev = Read_APP_Feature_Info(0x02,&g_app_feature);
    if(rev == 0x00)
    {
        DBG_SYS_Printf("SPIFlash APP Feature Check Succ");
        APP_Feature_Info_Printf(&g_app_feature);

        /*判断APP 标志位是否成立*/
        if(g_app_feature.app_flag == App_Procedure_Ready)
        {
            /*判断APP 起始地址、结束地址以及CRC校验大小是否在范围内*/
            if( ( g_app_feature.app_start_addr < MCU_APP_Flash_Start_Addr )     \
                    || ( g_app_feature.app_end_addr > MCU_APP_Flash_End_Addr )  \
                    || ( g_app_feature.app_crc_size != MCU_APP_Flash_PageSize ) )
            {
                DBG_SYS_Printf("SPIFlash Flash APP ADDRESS ERROR!");
                LOG_Launcher_APP_Check_Record(0x03);
                return 1;
            }

            /*外部flash 校验APP数据*/
            crcNumIndex = 0;
            memset(g_read_buff,0,sizeof(g_read_buff));
            for(uint32_t i = g_app_feature.app_start_addr; i < g_app_feature.app_end_addr; i += g_app_feature.app_crc_size)
            {
                if( g_app_feature.app_end_addr - i >= g_app_feature.app_crc_size)    {
                    crc_data_len = g_app_feature.app_crc_size;
                }else {
                    crc_data_len = g_app_feature.app_end_addr - i;
                }

                memset(g_read_buff,0,sizeof(g_read_buff));

                if(crc_data_len > 2048)
                {
                    Flash_Read(g_read_buff,2048,i);
                    Flash_Read(&g_read_buff[2048],(crc_data_len - 2048),i+2048);
                }else {
                    Flash_Read(g_read_buff,crc_data_len,i);
                }

                crcVal = CRC16_Check(g_read_buff, crc_data_len);
                crcValH = crcVal >> 8;
                crcValL = crcVal & 0xFF;
                if((g_app_feature.app_crc[crcNumIndex + 1] != crcValH) || (g_app_feature.app_crc[ crcNumIndex] != crcValL))
                {
                    DBG_SYS_Printf("block:%d , app_crc:%x%x , crcVal:%X\r\n",crcNumIndex,g_app_feature.app_crc[crcNumIndex],g_app_feature.app_crc[1 + crcNumIndex],crcVal);

                    Dbg_Print_Buff(DBG_BIT_SYS_STATUS,"Read Flash:",g_read_buff,MCU_APP_Flash_PageSize);

                    crcResultFlag = FALSE;
                    break;
                }
                crcNumIndex+=2;
            }
            if(crcResultFlag == FALSE)
            {
                DBG_SYS_Printf("SPI FLash APP ERROR! - 擦除APP数据\r\n");

                //擦除Flash APP特征区数据
                Flash_Erase_Pageaddr(SPIFLASH_APP_FEATURE_Addr);

                LOG_Launcher_APP_Check_Record(0x04);
                return 1;       //校验失败
            }
        }else{
            LOG_Launcher_APP_Check_Record(0x05);
            return 1;       //没APP数据
        }
    }else {
        DBG_SYS_Printf("SPIFlash APP Feature Check Fail \r\n");
        LOG_Launcher_APP_Check_Record(0x06);
        return 1;
    }

    /*第二步：读取上一次写入Flash 的APP特征区，对比是否是新固件，是否需要更新*/
    rev = SPIFLASH_Read_APP_Update_Flag_Info(&g_update_flag);
    if(rev == 0x00)
    {
        /*读取更新标志位成功*/
        if( (g_update_flag.app_start_addr != g_app_feature.app_start_addr)
            || (g_update_flag.app_end_addr != g_app_feature.app_end_addr)
            || (g_update_flag.app_crc_size != g_app_feature.app_crc_size)
            || (g_update_flag.app_crc_len != g_app_feature.app_crc_len)
            )
        {
            update_flag = 0x01;
        }
        for(uint32_t i = 0;i < APP_Feature_CRC_Size; i++)
        {
            if( g_update_flag.app_crc[i] != g_app_feature.app_crc[i] )
            {
                update_flag = 0x01;
                break;
            }
        }

        if( update_flag == 0x01 )
        {
            /*说明现在这是个新的APP，
            *- 将app_flag 这个标志位设置为0x05，这个标志位作为APP 固件写入次数
            *- 每写入一次，app_flag 这个标志位减1，直到减为0，便不在升级操作。
             * */
            g_update_flag.app_flag = 0x05;
        }else {
            /* - 该APP之前没有写入成功，还可以写入次数还有
             * */
            if( (g_update_flag.app_flag != 0x00) && (g_update_flag.app_flag != App_Procedure_Ready) && (g_update_flag.app_flag <= 0x05) )
            {
                g_update_flag.app_flag--;
                update_flag = 0x02;
            }
        }
    }else {
        /*读取更新标志位失败 - 也认为是新的固件*/
        update_flag = 0x01;
        g_update_flag.app_flag = 0x05;
    }

    if( update_flag == 0x01 )
    {
        g_update_flag.app_start_addr = g_app_feature.app_start_addr;
        g_update_flag.app_end_addr = g_app_feature.app_end_addr;
        g_update_flag.app_crc_size = g_app_feature.app_crc_size;
        g_update_flag.app_crc_len = g_app_feature.app_crc_len;
        for(uint32_t i = 0;i < APP_Feature_CRC_Size; i++)
        {
            g_update_flag.app_crc[i] = g_app_feature.app_crc[i];
        }

        DBG_SYS_Printf("--这是新的APP固件--");
        SPIFLASH_Write_APP_Upate_Flag_Info(&g_update_flag);
    }else if( update_flag == 0x02 ){
        DBG_SYS_Printf("--APP固件需要升级，剩余升级次数:%d --",g_update_flag.app_flag);
        SPIFLASH_Write_APP_Upate_Flag_Info(&g_update_flag);
    }else{
        DBG_SYS_Printf("--APP固件无需升级:%x--",g_update_flag.app_flag);
    }


    /*第三步：先读取MCU Flash的APP特征区是否有数据，同时验证APP的合法性*/
    rev = Read_APP_Feature_Info(0x01,&g_mcu_app_feature);
    if(rev == 0x00)
    {
        DBG_SYS_Printf("MCU Flash APP Feature Check Succ");
        APP_Feature_Info_Printf(&g_mcu_app_feature);

        /*判断APP 标志位是否成立*/
        if(g_mcu_app_feature.app_flag == App_Procedure_Ready)
        {
            /*判断APP 起始地址、结束地址以及CRC校验大小是否在范围内*/
            if( ( g_mcu_app_feature.app_start_addr < MCU_APP_Flash_Start_Addr )     \
                    || ( g_mcu_app_feature.app_end_addr > MCU_APP_Flash_End_Addr )  \
                    || ( g_mcu_app_feature.app_crc_size != MCU_APP_Flash_PageSize ) )
            {
                DBG_SYS_Printf("MCU Flash APP ADDRESS ERROR!");
                LOG_Launcher_APP_Check_Record(0x03);
                return 1;
            }

            /*外部flash 校验APP数据*/
            crcNumIndex = 0;
            memset(g_read_buff,0,sizeof(g_read_buff));
            for(uint32_t i = g_mcu_app_feature.app_start_addr; i < g_mcu_app_feature.app_end_addr; i += g_mcu_app_feature.app_crc_size)
            {
                if( g_app_feature.app_end_addr - i >= g_app_feature.app_crc_size)    {
                    crc_data_len = g_app_feature.app_crc_size;
                }else {
                    crc_data_len = g_app_feature.app_end_addr - i;
                }

                memset(g_read_buff,0,sizeof(g_read_buff));

                MCU_APP_Flash_Read(g_read_buff ,crc_data_len,i);

                crcVal = CRC16_Check(g_read_buff, crc_data_len);
                crcValH = crcVal >> 8;
                crcValL = crcVal & 0xFF;
                if((g_mcu_app_feature.app_crc[crcNumIndex + 1] != crcValH) || (g_mcu_app_feature.app_crc[crcNumIndex] != crcValL))
                {
                    DBG_SYS_Printf("block:%d , app_crc:%x%x , crcVal:%X\r\n",crcNumIndex,g_mcu_app_feature.app_crc[crcNumIndex],g_mcu_app_feature.app_crc[1 + crcNumIndex],crcVal);

                    Dbg_Print_Buff(DBG_BIT_SYS_STATUS,"Read Flash:",g_read_buff,MCU_APP_Flash_PageSize);

                    crcResultFlag = FALSE;
                    break;
                }
                crcNumIndex+=2;
            }
            if(crcResultFlag == FALSE)
            {
                DBG_SYS_Printf("APP ERROR! \r\n");

                LOG_Launcher_APP_Check_Record(0x07);

                if(update_flag != 0x00)
                {
                    return 2;       //需要升级
                }else {
                    return 3;       //不需要升级
                }
            }
        }else{
            LOG_Launcher_APP_Check_Record(0x08);

            if(update_flag != 0x00)
            {
                return 2;       //需要升级
            }else {
                return 3;       //不需要升级
            }
        }
    }else {
        DBG_SYS_Printf("MCU Feature ERROR! \r\n");
        LOG_Launcher_APP_Check_Record(0x09);

        if(update_flag != 0x00)
        {
            return 2;       //需要升级
        }else {
            return 3;       //不需要升级
        }
    }

    /*判断MCU Flash中的特征区内容是否与外部SPI Flash中的特征区内容是否一致*/
    if(g_app_feature.app_crc_len != g_mcu_app_feature.app_crc_len)  {
        DBG_SYS_Printf("app_crc_len different!\r\n");
        LOG_Launcher_APP_Check_Record(0x02);

        if(update_flag != 0x00)
        {
            return 2;       //需要升级
        }else {
            return 3;       //不需要升级
        }
    }

    if(g_app_feature.app_start_addr != g_mcu_app_feature.app_start_addr)  {
        DBG_SYS_Printf("app_start_addr different!\r\n");
        LOG_Launcher_APP_Check_Record(0x02);

        if(update_flag != 0x00)
        {
            return 2;       //需要升级
        }else {
            return 3;       //不需要升级
        }
    }

    if(g_app_feature.app_end_addr != g_mcu_app_feature.app_end_addr)  {
        DBG_SYS_Printf("app_end_addr different!\r\n");
        LOG_Launcher_APP_Check_Record(0x02);

        if(update_flag != 0x00)
        {
            return 2;       //需要升级
        }else {
            return 3;       //不需要升级
        }
    }

    for(uint16_t j = 0;j<g_app_feature.app_crc_len;j++)
    {
        if(g_mcu_app_feature.app_crc[j] != g_app_feature.app_crc[j])
        {
            LOG_Launcher_APP_Check_Record(0x02);

            if(update_flag != 0x00)
            {
                return 2;       //需要升级
            }else {
                return 3;       //不需要升级
            }
        }
    }

    if(update_flag != 0x00)
    {
        /*外部存储的APP 更新的标志位出错
         * 其实MCU Flash中已经是最新的APP程序了，无需更新
         * */
        DBG_SYS_Printf("外部存储的APP 更新的标志位出错!!!");
        g_update_flag.app_flag = App_Procedure_Ready;
        SPIFLASH_Write_APP_Upate_Flag_Info(&g_update_flag);
    }

    /*没问题了 准备 跳转APP*/
    LOG_Launcher_APP_Check_Record(0x00);
    return 0x00;
}

/*******************************************************************************
* Function Name  : MCU_APP_Write
* Description    : MCU Flash APP区数据写入函数
* Input          :
*******************************************************************************/
uint8_t MCU_APP_Write(void)
{
    uint8_t rev = 0;
    uint8_t crcValH = 0, crcValL = 0;
    uint16_t crcVal = 0,crcNumIndex = 0;
    uint32_t crc_data_len = 0;


    g_update_recode.mcuflash_fw_count++;

    DBG_SYS_Printf("MCU Flash 擦除APP程序");

    rev = MCU_APP_Flash_ALLErase();        //先擦除 全部APP程序
    if(rev != 0) {
        DBG_SYS_Printf("MCU Flash 擦除APP程序 失败");
        return 0x01;
    }

    if( ( g_app_feature.app_start_addr < MCU_APP_Flash_Start_Addr ) || ( g_app_feature.app_start_addr > MCU_APP_Data_End_Addr ) ){
        DBG_SYS_Printf("MCU Flash app_start_addr:0x%x Error",g_app_feature.app_start_addr);
        return 0x01;
    }

    if( ( g_app_feature.app_end_addr > MCU_APP_Data_End_Addr ) || ( g_app_feature.app_start_addr > g_app_feature.app_end_addr ) ){
        DBG_SYS_Printf("MCU Flash app_end_addr:0x%x - 0x%x Error",g_app_feature.app_start_addr,g_app_feature.app_end_addr);
        return 0x01;
    }

    if( g_app_feature.app_crc_size != MCU_APP_Flash_PageSize ){
        DBG_SYS_Printf("MCU Flash app_crc_size:%x Error",g_app_feature.app_crc_size);
        return 0x01;
    }

    /*1、写入APP Flash数据 - 按照块大小写入APP Flash数据内容*/
    for(uint32_t i = g_app_feature.app_start_addr;i < g_app_feature.app_end_addr;i += MCU_APP_Flash_PageSize )
    {
        if( g_app_feature.app_end_addr - i >= g_app_feature.app_crc_size)    {
            crc_data_len = g_app_feature.app_crc_size;
        }else {
            crc_data_len = g_app_feature.app_end_addr - i;
        }

        memset(g_read_buff,0,sizeof(g_read_buff));

        if(crc_data_len > 2048)
        {
            Flash_Read(g_read_buff,2048,i);
            Flash_Read(&g_read_buff[2048],(crc_data_len - 2048),i+2048);
        }else {
            Flash_Read(g_read_buff,crc_data_len,i);
        }

        DBG_SYS_Printf("MCU Write APP Addr:%x",i);

        rev = MCU_APP_Flash_Write(g_read_buff,crc_data_len,i);

        if(rev != 0x00){
            DBG_SYS_Printf("MCU Flash Write:%x Error",i);

            return 0x01;
        }
    }

    /*2、写入APP 特征区数据*/
    g_mcu_app_feature.app_flag = g_app_feature.app_flag;
    g_mcu_app_feature.app_start_addr = g_app_feature.app_start_addr;
    g_mcu_app_feature.app_end_addr = g_app_feature.app_end_addr;
    g_mcu_app_feature.app_crc_size = g_app_feature.app_crc_size;
    g_mcu_app_feature.app_crc_len = g_app_feature.app_crc_len;
    g_mcu_app_feature.crc_check = g_app_feature.crc_check;
    memcpy(g_mcu_app_feature.app_crc,g_app_feature.app_crc,APP_Feature_CRC_Size);
    rev = Write_APP_Feature_Info(0x01,&g_mcu_app_feature);
    if(rev != 0x00){
        DBG_SYS_Printf("MCU Write APP Feature_Info Error");

        return 0x01;
    }

    /*3、读取APP特征区数据，且对APP Flash数据进行CRC校验*/
    rev = Read_APP_Feature_Info(0x01,&g_mcu_app_feature);
    if(rev != 0x00){
        DBG_SYS_Printf("MCU Read APP Feature_Info Error");

        return 0x01;
    }

    for(uint32_t i = g_mcu_app_feature.app_start_addr; i < g_mcu_app_feature.app_end_addr; i += MCU_APP_Flash_PageSize)
    {
        if( g_app_feature.app_end_addr - i >= g_app_feature.app_crc_size)    {
            crc_data_len = g_app_feature.app_crc_size;
        }else {
            crc_data_len = g_app_feature.app_end_addr - i;
        }

        memset(g_read_buff,0,sizeof(g_read_buff));

        rev = MCU_APP_Flash_Read(g_read_buff,crc_data_len,i);
        //Dbg_Print_Buff(DBG_BIT_SYS_STATUS, "MCU Flash:", g_read_buff, crc_data_len);

        crcVal = CRC16_Check(g_read_buff, crc_data_len);
        crcValH = crcVal >> 8;
        crcValL = crcVal & 0xFF;

        DBG_SYS_Printf("MCU Write APP Addr:%x - CRC:%x",i,crcVal);

        if( ( g_mcu_app_feature.app_crc[crcNumIndex + 1] != crcValH ) || ( g_mcu_app_feature.app_crc[crcNumIndex] != crcValL ) )
        {
            DBG_SYS_Printf("Addr:%x app_crc:%x%x crcVal:%x ",i,g_mcu_app_feature.app_crc[crcNumIndex],g_mcu_app_feature.app_crc[1 + crcNumIndex],crcVal);
            Dbg_Print_Buff(DBG_BIT_SYS_STATUS, "MCU Flash CRC Error:", g_read_buff, crc_data_len);

            if(crc_data_len > 2048)
            {
                Flash_Read(g_read_buff,2048,i);
                Flash_Read(&g_read_buff[2048],(crc_data_len - 2048),i+2048);
            }else {
                Flash_Read(g_read_buff,crc_data_len,i);
            }
            Dbg_Print_Buff(DBG_BIT_SYS_STATUS, "SPI Flash:", g_flash_buff, MCU_APP_Flash_PageSize);

            for(uint32_t t_addr = 0;t_addr < crc_data_len;t_addr++ )
            {
                if(g_read_buff[t_addr] != g_flash_buff[t_addr])
                {
                    DBG_SYS_Printf("Different Addr:%x %x - %x",i+t_addr,g_read_buff[t_addr],g_flash_buff[t_addr]);
                }
            }

            /*写入失败 - 失败次数加一*/
            g_update_recode.mcuflash_fw_fail++;
            SPIFLASH_Write_Update_Recode(&g_update_recode);
            SPIFLASH_Read_Update_Recode(&g_update_recode);      //读取APP写入次数
            return 0x01;
        }

        crcNumIndex += 2;
    }

    /*写入成功 - 成功次数加一*/
    g_update_recode.mcuflash_fw_succ++;
    SPIFLASH_Write_Update_Recode(&g_update_recode);

    /*APP更新标志位 - 状态更新为文件就绪*/
    g_update_flag.app_flag = App_Procedure_Ready;
    SPIFLASH_Write_APP_Upate_Flag_Info(&g_update_flag);
    SPIFLASH_Read_Update_Recode(&g_update_recode);      //读取APP写入次数

    /*4、校验成功*/
    DBG_SYS_Printf("MCU APP Update Succ!!");
    LOG_Launcher_Read_App_Record(0x00);

    return 0x00;
}

/*******************************************************************************
* Function Name  : SPIFLASH_Read_Update_Recode
* Description    : MCU Flash APP区数据写入函数
* Input          :
*******************************************************************************/
uint8_t SPIFLASH_Read_Update_Recode(UPDATE_RECORD_T *info)
{
    uint16_t read_len = 0;

    memset(g_flash_buff,0,sizeof(g_flash_buff));

    Flash_Read(g_flash_buff, APP_FEATURE_SIZE, SPIFLASH_UPDATE_RECORD_Addr);

    if(g_flash_buff[EEPROM_Offset_SaveFlag] == EEPROM_SVAE_FLAG)
    {
        read_len = g_flash_buff[EEPROM_Offset_Datalen + 1];
        read_len <<= 8;
        read_len |= g_flash_buff[EEPROM_Offset_Datalen];

        DBG_SYS_Printf("%s read_len : %d ",__func__,read_len);
        if(read_len == sizeof(UPDATE_RECORD_T) )
        {
            if(EEPROM_CheckSum(&g_flash_buff[EEPROM_Offset_Data],read_len) == g_flash_buff[EEPROM_Offset_Check]){

                memcpy((uint8_t *)info,&g_flash_buff[EEPROM_Offset_Data],read_len);

                DBG_SYS_Printf("mcu flash_fw_count:%d",info->mcuflash_fw_count);
                DBG_SYS_Printf("mcu flash_fw_succ:%d",info->mcuflash_fw_succ);
                DBG_SYS_Printf("mcu flash_fw_fail:%d",info->mcuflash_fw_fail);

                return 0x00;    //读取成功
            }else {
                DBG_SYS_Printf("%s Check Error !",__func__);
            }
        }else {
            DBG_SYS_Printf("%s Len Error !",__func__);
        }
    }else{
        DBG_SYS_Printf("%s Flag Error !",__func__);
    }

    /*读取失败 - 将数据清零从新开始计数*/
    info->mcuflash_fw_count = 0x00;
    info->mcuflash_fw_succ = 0x00;
    info->mcuflash_fw_fail = 0x00;

    return 0x01;        //读取失败
}

/*******************************************************************************
* Function Name  : SPIFLASH_Write_Update_Recode
* Description    : SPI Flash 写入APP更新记录
* Input          :
*******************************************************************************/
uint8_t SPIFLASH_Write_Update_Recode(UPDATE_RECORD_T *info)
{
    uint16_t save_len = sizeof(UPDATE_RECORD_T);
    memset(g_flash_buff,0,sizeof(g_flash_buff));

    g_flash_buff[EEPROM_Offset_SaveFlag] = EEPROM_SVAE_FLAG;
    g_flash_buff[EEPROM_Offset_Datalen] = save_len & 0xFF;
    g_flash_buff[EEPROM_Offset_Datalen + 1] = (save_len >> 8) & 0xFF;

    memcpy(&g_flash_buff[EEPROM_Offset_Data],(uint8_t *)info,save_len);

    g_flash_buff[3] = EEPROM_CheckSum(&g_flash_buff[EEPROM_Offset_Data],save_len);
    save_len+=4;

    Flash_Write(g_flash_buff, APP_FEATURE_SIZE, SPIFLASH_UPDATE_RECORD_Addr);

    return 0x00;
}

/*******************************************************************************
* Function Name  : Read_APP_Update_Flag_Info
* Description    : 读取APP更新特征区
*   APP特征区数据存在在外部的FLash与SRAM中：
*           1、先读取外部Flash，如果外部Flash中读取失败，便读取外部SRAM中读取；
*           2、外部SRAM也读取失败了，便认为之前没有APP更新记录
* Para           :
*   flag_info       -   APP更新特征区
*  Return        ：
*   0x00    -   读取成功
*   0x01    -   读取失败
*******************************************************************************/
uint8_t SPIFLASH_Read_APP_Update_Flag_Info(G_SYS_FEATURE_T *feature_info)
{
    uint16_t crc_val = 0,crc_val2 = 0;
    uint32_t temp_val = 0;

    memset(g_read_buff,0,sizeof(g_read_buff));

    Flash_Read(g_read_buff,APP_FEATURE_SIZE,SPIFLASH_UPDATE_FLAG_Addr);

    crc_val = g_read_buff[1];
    crc_val <<= 0x08;
    crc_val |= g_read_buff[0];

    crc_val2 = CRC16_Check(&g_read_buff[2],510);
    DBG_SYS_Printf("%s Flash CRC: %x - %x",__func__,crc_val,crc_val2);

    if(crc_val != crc_val2)
    {
        //校验失败了，改为读取外部SRAM
        memset(g_read_buff,0,sizeof(g_read_buff));
        SRAM_DMA_Read_Buff(g_read_buff, APP_FEATURE_SIZE, SRAM_APP_Write_Count_Addr);

        crc_val = g_read_buff[1];
        crc_val <<= 0x08;
        crc_val |= g_read_buff[0];

        crc_val2 = CRC16_Check(&g_read_buff[2],510);
        DBG_SYS_Printf("%s SRAM CRC: %x - %x",__func__,crc_val,crc_val2);

        if(crc_val != crc_val2)
        {
            return 0x01;    //读取失败
        }
    }

    /*数据校验通过*/
    feature_info->app_flag = g_read_buff[Feature_AppFlag];

    temp_val = g_read_buff[Feature_AppStart + 3];
    temp_val <<= 8;
    temp_val |= g_read_buff[Feature_AppStart + 2];
    temp_val <<= 8;
    temp_val |= g_read_buff[Feature_AppStart + 1];
    temp_val <<= 8;
    temp_val |= g_read_buff[Feature_AppStart];
    feature_info->app_start_addr = temp_val;

    temp_val = g_read_buff[Feature_AppEnd + 3];
    temp_val <<= 8;
    temp_val |= g_read_buff[Feature_AppEnd + 2];
    temp_val <<= 8;
    temp_val |= g_read_buff[Feature_AppEnd + 1];
    temp_val <<= 8;
    temp_val |= g_read_buff[Feature_AppEnd];
    feature_info->app_end_addr = temp_val;

    temp_val = g_read_buff[Feature_AppCrcSize + 1];
    temp_val <<= 8;
    temp_val |= g_read_buff[Feature_AppCrcSize];
    feature_info->app_crc_size = temp_val;

    temp_val = g_read_buff[Feature_AppCrcLen + 1];
    temp_val <<= 8;
    temp_val |= g_read_buff[Feature_AppCrcLen];
    feature_info->app_crc_len = temp_val;

    memcpy(feature_info->app_crc,&g_read_buff[Feature_AppFlashCrc],APP_Feature_CRC_Size);

    /*校验数据是否处于正常范围*/
    if( ( feature_info->app_start_addr < MCU_APP_Flash_Start_Addr ) || ( feature_info->app_start_addr > MCU_APP_Data_End_Addr ) ){
        DBG_SYS_Printf("%s app_start_addr:0x%x Error",__func__, feature_info->app_start_addr);
        return 0x02;
    }

    if( ( feature_info->app_end_addr > MCU_APP_Data_End_Addr ) || ( feature_info->app_start_addr > feature_info->app_end_addr ) ){
        DBG_SYS_Printf("%s app_end_addr:0x%x - 0x%x Error",__func__,feature_info->app_start_addr,feature_info->app_end_addr);
        return 0x02;
    }

    if( feature_info->app_crc_size != MCU_APP_Flash_PageSize ){
        DBG_SYS_Printf("%s app_crc_size:%#x Error",__func__,feature_info->app_crc_size);
        return 0x02;
    }

    return 0x00;    //读取成功
}

/*******************************************************************************
* Function Name  : SPIFLASH_Write_APP_Upate_Flag_Info
* Description    : 写入APP更新特征区
*   APP特征区数据存在在外部的FLash与SRAM中
* Para           :
*   flag_info       -   APP更新特征区数据
*  Return        ：
*   0x00    -   写入成功
*   0x01    -   写入失败
*******************************************************************************/
uint8_t SPIFLASH_Write_APP_Upate_Flag_Info(G_SYS_FEATURE_T *flag_info)
{
    memset(g_read_buff,0,sizeof(g_read_buff));

    g_read_buff[Feature_AppFlag] = flag_info->app_flag;

    g_read_buff[Feature_AppStart] = flag_info->app_start_addr & 0xFF;
    g_read_buff[Feature_AppStart + 1] = ( flag_info->app_start_addr >> 8 ) & 0xFF;
    g_read_buff[Feature_AppStart + 2] = ( flag_info->app_start_addr >> 16 ) & 0xFF;
    g_read_buff[Feature_AppStart + 3] = ( flag_info->app_start_addr >> 24 ) & 0xFF;

    g_read_buff[Feature_AppEnd] = flag_info->app_end_addr & 0xFF;
    g_read_buff[Feature_AppEnd + 1] = ( flag_info->app_end_addr >> 8 ) & 0xFF;
    g_read_buff[Feature_AppEnd + 2] = ( flag_info->app_end_addr >> 16 ) & 0xFF;
    g_read_buff[Feature_AppEnd + 3] = ( flag_info->app_end_addr >> 24 ) & 0xFF;

    g_read_buff[Feature_AppCrcSize] = flag_info->app_crc_size & 0xFF;
    g_read_buff[Feature_AppCrcSize + 1] = ( flag_info->app_crc_size >> 8 ) & 0xFF;

    g_read_buff[Feature_AppCrcLen] = flag_info->app_crc_len & 0xFF;
    g_read_buff[Feature_AppCrcLen + 1] = ( flag_info->app_crc_len >> 8 ) & 0xFF;

    memcpy(&g_read_buff[Feature_AppFlashCrc],flag_info->app_crc,APP_Feature_CRC_Size);

    flag_info->crc_check = CRC16_Check(&g_read_buff[2], 510);

    g_read_buff[Feature_Check] = flag_info->crc_check & 0xFF;
    g_read_buff[Feature_Check + 1] = ( flag_info->crc_check >> 8 ) & 0xFF;

    /* 向Flash与SRAM中都写入APP更新特征区数据 */
    Flash_Write(g_read_buff,APP_FEATURE_SIZE,SPIFLASH_UPDATE_FLAG_Addr);
    SRAM_DMA_Write_Buff(g_read_buff, APP_FEATURE_SIZE, SRAM_APP_Write_Count_Addr);

    return 0;
}