/*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/

#include "configprotocal.h"

#include "main.h"
#include "eerom.h"

//**********************************************************

//**********************************************************
#pragma   pack(4)
typedef struct _prococal_state
{
    uint16_t len;
    uint16_t index;
    uint16_t maxlen;
    uint16_t state;
    uint8_t buffer[MAX_MESSAGE_LEN];
}stBufferState;

#pragma   pack(4)
typedef struct _debug_msg_slot
{
    uint16_t flag;
    uint16_t len;
    uint8_t message[MAX_MESSAGE_LEN];
}stDebugMsgSlot;

#pragma   pack(4)
typedef struct{
    uint8_t status;
    uint8_t index;
    uint8_t tail;
    uint8_t count;
    stDebugMsgSlot msgSlots[MESSAGE_SLOT_COUNT];
}stDebugStatus;


//**********************************************************
volatile stBufferState rxBufState = {0};
volatile stBufferState txBufState = {0};
uint8_t tempBuf[MAX_MESSAGE_LEN]={0};
stWriteMemoryStatus writeMemoryStatus;
char dbgBuffer[256];

const stServerConfig defaultWifiServer = {
    .ip = "192.168.4.100",
    .port = "8085",
};
const stWifiConfig defaultWifiConfig = {
	.type = 1,
    .mode = 1,
	.rfpower = 82,
	.dhcp = 0,
    .name = "ScenLoc2G4",
    .password = "qwpozxmn",
};
const stNetworkConfig defaultWifiNetwork = {
    .ip = "192.168.4.150",
    .subnetmask = "255.255.255.0",
    .gateway = "192.168.4.1",
};

stServerConfig wifiServer = {
    .ip = "192.168.4.100",
    .port = "8085",
};
stWifiConfig wifiConfig = {
	.type = 1,
    .mode = 1,
	.rfpower = 82,
	.dhcp = 0,
    .name = "ScenLoc2G4",
    .password = "qwpozxmn",
};
stNetworkConfig wifiNetwork = {
    .ip = "192.168.4.150",
    .subnetmask = "255.255.255.0",
    .gateway = "192.168.4.1",
};

#if 0
volatile stDebugBuffer debugBufferArray[MAX_BUF_COUNT] = {0};
volatile uint32_t debugBufferFlag = 0;
#else
volatile stDebugStatus debugStatus={0};
#endif

volatile uint32_t cmdStartTime = 0;

uint32_t resetFlag = 0;
//**********************************************************
void Wifi_SetDefault(void)
{
    wifiServer = defaultWifiServer ;
    wifiNetwork = defaultWifiNetwork;
    wifiConfig = defaultWifiConfig;
}


#ifndef STM32F405_BOOTLOADER
//**********************************************************

#define PROTOCAL_CMD_FILTER                 0x80
#define PROTOCAL_CMD_CONFIG                 0x80
int32_t DataPackageHeadHandler(uint8_t* buf, uint32_t len)
{
    if(buf == NULL)
    {//Failed: unavailible arguments
        return -1;
    }
    if( len < PROTOCAL_HEAD_LENGTH)
    {//Continue
        return 0;
    }

    uint8_t cmd = buf[PROTOCAL_CMD_INDEX] & PROTOCAL_CMD_FILTER;
    uint16_t datalen = (uint16_t)(buf[PROTOCAL_LENLOW_INDEX]+((buf[PROTOCAL_LENHIGH_INDEX]&0x0f)<<8));
    if((PROTOCAL_HEAD_FLAG == buf[PROTOCAL_START_INDEX] ||  PROTOCAL_HEAD_ENCRYPT_FLAG == buf[PROTOCAL_START_INDEX]) &&
       PROTOCAL_MIN_LENGTH <= datalen &&
       PROTOCAL_CMD_CONFIG == cmd)//STX & LEN & CMD
    { //succedd
        cmdStartTime = HAL_GetTick();
        return 1;
    }
    else if( CFG_COMMAND_STARTLOADER == buf[PROTOCAL_START_INDEX] &&
             CFG_COMMAND_STARTLOADER == buf[PROTOCAL_LENLOW_INDEX] &&
             CFG_COMMAND_STARTLOADER == buf[PROTOCAL_LENHIGH_INDEX] &&
             CFG_COMMAND_STARTLOADER == buf[PROTOCAL_CMD_INDEX])
    {
        //ClearReceiveBuffer();
        SaveRunStatus(0, 1);
		SaveRunStatus2(0, 1);
        BSP_IAP_APP_Jump();
        return -2;
    }
    else
    { //Failed: bad head of package
        //ClearReceiveBuffer();
        return -2;
    }
}

int32_t DataPackageCompleteHandler(uint8_t* buf, uint32_t len, uint8_t* retbuf, uint32_t* retlen)
{
    *retlen = 0;
    if(buf==NULL || retbuf==NULL || retlen == NULL)
    {//Failed: unavailible arguments
        return -1;
    }

    int buflen = (uint16_t)(buf[PROTOCAL_LENLOW_INDEX]+((buf[PROTOCAL_LENHIGH_INDEX]&0x0f)<<8));
    buflen += PROTOCAL_HEAD_LENGTH -1;
    if(len < buflen)
    {//Continue
        uint32_t curtick = HAL_GetTick();
        if(cmdStartTime > curtick)
        {
          cmdStartTime = curtick;
        }
        if(curtick - cmdStartTime > COMMAND_FRAME_TIMEOUT)
        {
            BuildSettingResponse(buf[PROTOCAL_CMD_INDEX], -3, retbuf, retlen);
            return -3;
        }
        return 0;
    }

    uint16_t checkval = CalculateCRC16(buf, buflen - PROTOCAL_CHECKSUM_LENGTH);
    uint16_t checksum = (uint16_t)(buf[buflen-2] + (buf[buflen-1]<<8));
    if(checkval != checksum)
    { //Failed: check error
        //ClearReceiveBuffer();
        BuildSettingResponse(buf[PROTOCAL_CMD_INDEX], -2, retbuf, retlen);
        return -2;
    }

    uint8_t headerSign = buf[PROTOCAL_START_INDEX];
    if (PROTOCAL_HEAD_ENCRYPT_FLAG == headerSign)
    {
        DecryptTEA(buf, PROTOCAL_DATASTART_INDEX, len - PROTOCAL_HEAD_LENGTH - PROTOCAL_CHECKSUM_LENGTH);
    }

    int retval=0;
    int rx = 0;
    uConverterUint2Bytes ubConvert;
    uint16_t datalen = buflen - PROTOCAL_CHECKSUM_LENGTH - PROTOCAL_HEAD_LENGTH;//datalen in frame
    switch(buf[PROTOCAL_CMD_INDEX])
    {
    case CFG_COMMAND_GETINFORM:
        {
            BuildResponse(CFG_COMMAND_GETINFORM, retbuf, retlen);
            buflen = 1;
        }
        break;

    case CFG_COMMAND_TIMESET:
        {
            rtcTime.tm_year = buf[PROTOCAL_DATASTART_INDEX+0];
            rtcTime.tm_mon  = buf[PROTOCAL_DATASTART_INDEX+1];
            rtcTime.tm_mday = buf[PROTOCAL_DATASTART_INDEX+2];
            rtcTime.tm_hour = buf[PROTOCAL_DATASTART_INDEX+3];
            rtcTime.tm_min  = buf[PROTOCAL_DATASTART_INDEX+4];
            rtcTime.tm_sec  = buf[PROTOCAL_DATASTART_INDEX+5];

            if (rtcTime.tm_mon > 0)
            {
                ExcuteTimeSettingCommand();
            }

            BuildSettingResponse(CFG_COMMAND_TIMESET, 0, retbuf, retlen);

            buflen = 1;
        }
        break;
    case CFG_COMMAND_GETTIME:
        {
            UpdateDateTime();

            BuildResponse(CFG_COMMAND_GETTIME, retbuf, retlen);

            buflen = 1;
        }
        break;

    case CFG_COMMAND_TAGCOMMAND:
        {
            buflen = buflen - PROTOCAL_CHECKSUM_LENGTH - PROTOCAL_HEAD_LENGTH;
            buflen = UpdateTagCommand(buf+PROTOCAL_DATASTART_INDEX, buflen);
            buflen = (buflen >= 0) ? 0 : buflen;

            BuildSettingResponse(CFG_COMMAND_TAGCOMMAND, buflen, retbuf, retlen);

            buflen = 1;
        }
        break;

    case CFG_COMMAND_GETCONFIGRANGE: //DMW
        {
            BuildResponse(CFG_COMMAND_GETCONFIGRANGE, retbuf, retlen);

            buflen = 1;
        }
        break;

    case CFG_COMMAND_GETCONFIGETHDBGSERVER: //ETH DBG SERVER IPPORT
        {
            BuildResponse(CFG_COMMAND_GETCONFIGETHDBGSERVER, retbuf, retlen);

            buflen = 1;
        }
        break;

    case CFG_COMMAND_GETCONFIGETHSERVER: //ETH SERVER IPPORT
        {
            BuildResponse(CFG_COMMAND_GETCONFIGETHSERVER, retbuf, retlen);

            buflen = 1;
        }
        break;

    case CFG_COMMAND_GETCONFIGETHLOCAL: //ETH LOCAL IPPORT...
        {
            BuildResponse(CFG_COMMAND_GETCONFIGETHLOCAL, retbuf, retlen);

            buflen = 1;
        }
        break;

    case CFG_COMMAND_GETCONFIGETHMAC: //ETHMAC
        {
            BuildResponse(CFG_COMMAND_GETCONFIGETHMAC, retbuf, retlen);

            buflen = 1;
        }
        break;

    case CFG_COMMAND_GETCONFIGAPSSID: //WIFI SSID
        {
            BuildResponse(CFG_COMMAND_GETCONFIGAPSSID, retbuf, retlen);

            buflen = 1;
        }
        break;

    case CFG_COMMAND_GETCONFIGAPPSWD: //WIFI PSWD
        {
            BuildResponse(CFG_COMMAND_GETCONFIGAPPSWD, retbuf, retlen);

            buflen = 1;
        }
        break;

    case CFG_COMMAND_GETCONFIGWIFISERVER: //WIFI SERVER IP/PORT
        {
            BuildResponse(CFG_COMMAND_GETCONFIGWIFISERVER, retbuf, retlen);
            buflen = 1;
        }
        break;

    case CFG_COMMAND_GETCONFIGWIFILOCAL: //WIFI LOCAL IP/PORT...
        {
            BuildResponse(CFG_COMMAND_GETCONFIGWIFILOCAL, retbuf, retlen);

            buflen = 1;
        }
        break;

    case CFG_COMMAND_CONFIGRANGE://address
        {
            buflen = SaveDwmConfig( buf + PROTOCAL_DATASTART_INDEX);

            //Build response
            BuildSettingResponse(CFG_COMMAND_CONFIGRANGE, buflen, retbuf, retlen);

            buflen = 1;
        }
        break;
        /*case 0xc1://
        buflen = 0;
        break;
    case 0xc2://
        buflen = 0;
        break;*/
    case CFG_COMMAND_CONFIGETHDBGSERVER://Server IP&Port
        {
            buflen = SaveEthernetDbgServerConfig(buf+PROTOCAL_DATASTART_INDEX);

            //Build response
            BuildSettingResponse(CFG_COMMAND_CONFIGETHDBGSERVER, buflen, retbuf, retlen);

            buflen = 1;
        }
        break;    
    case CFG_COMMAND_CONFIGETHSERVER://Server IP&Port
        {
            buflen = SaveEthernetServerConfig(buf+PROTOCAL_DATASTART_INDEX);

            //Build response
            BuildSettingResponse(CFG_COMMAND_CONFIGETHSERVER, buflen, retbuf, retlen);

            buflen = 1;
        }
        break;
    case CFG_COMMAND_CONFIGETHLOCAL://Ethernet localIP, subnetmask, gateway
        {
            buflen =  SaveEthernetLocalConfig(buf+PROTOCAL_DATASTART_INDEX);

            //Build response
            BuildSettingResponse(CFG_COMMAND_CONFIGETHLOCAL, buflen, retbuf, retlen);
            buflen = 1;
        }
        break;
    case CFG_COMMAND_CONFIGETHMAC://Etherne MAC
        {
            buflen = SaveEthernetMacAddressConfig(buf+PROTOCAL_DATASTART_INDEX);

            //Build response
            BuildSettingResponse(CFG_COMMAND_CONFIGETHMAC, buflen, retbuf, retlen);

            buflen = 1;
        }
        break;
        /*case 0xc7://NA
        buflen = 0;
        break;*/
    case CFG_COMMAND_CONFIGAPSSID://AP SSID
        {
            buflen = (uint16_t)(buf[PROTOCAL_LENLOW_INDEX]+((buf[PROTOCAL_LENHIGH_INDEX]&0x0f)<<8));
            buflen = buflen - PROTOCAL_CHECKSUM_LENGTH - 1;
            buflen = SaveWifiApNameConfig(buf+PROTOCAL_DATASTART_INDEX, buflen);

            //Build response
            BuildSettingResponse(CFG_COMMAND_CONFIGAPSSID, buflen, retbuf, retlen);

            buflen = 1;
        }
        break;
    case CFG_COMMAND_CONFIGAPPSWD://AP Password
        {
            buflen = (uint16_t)(buf[PROTOCAL_LENLOW_INDEX]+((buf[PROTOCAL_LENHIGH_INDEX]&0x0f)<<8));
            buflen = buflen - PROTOCAL_CHECKSUM_LENGTH - 1;
            buflen = SaveWifiApPasswordConfig(buf+PROTOCAL_DATASTART_INDEX, buflen);

            //Build response
            BuildSettingResponse(CFG_COMMAND_CONFIGAPPSWD, buflen, retbuf, retlen);

            buflen = 1;
        }
        break;
    case CFG_COMMAND_CONFIGWIFISERVER://Wifi Server IP&port
        {
            buflen = SaveWifiServerConfig( buf + PROTOCAL_DATASTART_INDEX);

            //Build response
            BuildSettingResponse(CFG_COMMAND_CONFIGWIFISERVER, buflen, retbuf, retlen);
            buflen = 1;
        }
        break;
    case CFG_COMMAND_CONFIGWIFILOCAL: //WIFI localIP, subnetmask, gateway
        {
            buflen = SaveWifiNetworkConfig(buf + PROTOCAL_DATASTART_INDEX);

            //Build response
            BuildSettingResponse(CFG_COMMAND_CONFIGWIFILOCAL, buflen, retbuf, retlen);

            buflen = 1;
        }
        break;
        /*case 0xcc:
        buflen = 0;
        break;
    case 0xcd:
        buflen = 0;
        break;
    case 0xce:
        buflen = 0;
        break;
    case 0xcf:
        buflen = 0;
        break;*/
    case CFG_COMMAND_RESET:
        {
            resetFlag = buf[PROTOCAL_DATASTART_INDEX+0];
            resetFlag += (buf[PROTOCAL_DATASTART_INDEX+1] << 8);

            checksum = 2;
            //Build response
            memset(retbuf, 0, MAX_MESSAGE_LEN);
            retbuf[PROTOCAL_START_INDEX] = PROTOCAL_HEAD_FLAG;
            checkval = checksum + PROTOCAL_CHECKSUM_LENGTH + 1;
            retbuf[PROTOCAL_LENLOW_INDEX] = checkval;
            retbuf[PROTOCAL_LENHIGH_INDEX] = checkval>>8;
            retbuf[PROTOCAL_CMD_INDEX] = CFG_COMMAND_RESET;

            retbuf[PROTOCAL_DATASTART_INDEX+0] = resetFlag;//
            retbuf[PROTOCAL_DATASTART_INDEX+1] = resetFlag>>8;//

            checkval = CalculateCRC16(retbuf, checksum + PROTOCAL_HEAD_LENGTH);
            retbuf[checksum + PROTOCAL_HEAD_LENGTH] = checkval;
            retbuf[checksum + PROTOCAL_HEAD_LENGTH + 1] = checkval>>8;
            *retlen =  checksum + PROTOCAL_HEAD_LENGTH + PROTOCAL_CHECKSUM_LENGTH;

            buflen = 1;
        }
        break;

    case CFG_COMMAND_TESTLED:
        {
            testStatus.ledMask = buf[PROTOCAL_DATASTART_INDEX+0];
            testStatus.ledCommand = buf[PROTOCAL_DATASTART_INDEX+1];

            checksum = 2;
            //Build response
            memset(retbuf, 0, MAX_MESSAGE_LEN);
            retbuf[PROTOCAL_START_INDEX] = PROTOCAL_HEAD_FLAG;
            checkval = checksum + PROTOCAL_CHECKSUM_LENGTH + 1;
            retbuf[PROTOCAL_LENLOW_INDEX] = checkval;
            retbuf[PROTOCAL_LENHIGH_INDEX] = checkval>>8;
            retbuf[PROTOCAL_CMD_INDEX] = CFG_COMMAND_TESTLED;

            retbuf[PROTOCAL_DATASTART_INDEX+0] = testStatus.ledMask ;//
            retbuf[PROTOCAL_DATASTART_INDEX+1] = testStatus.ledCommand;//

            checkval = CalculateCRC16(retbuf, checksum + PROTOCAL_HEAD_LENGTH);
            retbuf[checksum + PROTOCAL_HEAD_LENGTH] = checkval;
            retbuf[checksum + PROTOCAL_HEAD_LENGTH + 1] = checkval>>8;
            *retlen =  checksum + PROTOCAL_HEAD_LENGTH + PROTOCAL_CHECKSUM_LENGTH;

            buflen = 1;
        }
        break;
    case CFG_COMMAND_TESTKEY:
        {
            checksum = 2;
            //Build response
            memset(retbuf, 0, MAX_MESSAGE_LEN);
            retbuf[PROTOCAL_START_INDEX] = PROTOCAL_HEAD_FLAG;
            checkval = checksum + PROTOCAL_CHECKSUM_LENGTH + 1;
            retbuf[PROTOCAL_LENLOW_INDEX] = checkval;
            retbuf[PROTOCAL_LENHIGH_INDEX] = checkval>>8;
            retbuf[PROTOCAL_CMD_INDEX] = CFG_COMMAND_TESTKEY;

            retbuf[PROTOCAL_DATASTART_INDEX+0] = testStatus.keyStatus ;//
            retbuf[PROTOCAL_DATASTART_INDEX+1] = 0;//

            checkval = CalculateCRC16(retbuf, checksum + PROTOCAL_HEAD_LENGTH);
            retbuf[checksum + PROTOCAL_HEAD_LENGTH] = checkval;
            retbuf[checksum + PROTOCAL_HEAD_LENGTH + 1] = checkval>>8;
            *retlen =  checksum + PROTOCAL_HEAD_LENGTH + PROTOCAL_CHECKSUM_LENGTH;

            buflen = 1;
        }
        break;
    case CFG_COMMAND_TESTSCREEN:
        {
            testStatus.screenFormat = buf[PROTOCAL_DATASTART_INDEX+0];
            testStatus.screenLocation = buf[PROTOCAL_DATASTART_INDEX+1];
            memcpy((void*)testStatus.screenString, buf+PROTOCAL_DATASTART_INDEX+2, 8);

            checksum = 2;
            //Build response
            memset(retbuf, 0, MAX_MESSAGE_LEN);
            retbuf[PROTOCAL_START_INDEX] = PROTOCAL_HEAD_FLAG;
            checkval = checksum + PROTOCAL_CHECKSUM_LENGTH + 1;
            retbuf[PROTOCAL_LENLOW_INDEX] = checkval;
            retbuf[PROTOCAL_LENHIGH_INDEX] = checkval>>8;
            retbuf[PROTOCAL_CMD_INDEX] = CFG_COMMAND_TESTSCREEN;

            retbuf[PROTOCAL_DATASTART_INDEX+0] = testStatus.screenFormat ;//
            retbuf[PROTOCAL_DATASTART_INDEX+1] = testStatus.screenLocation;//

            checkval = CalculateCRC16(retbuf, checksum + PROTOCAL_HEAD_LENGTH);
            retbuf[checksum + PROTOCAL_HEAD_LENGTH] = checkval;
            retbuf[checksum + PROTOCAL_HEAD_LENGTH + 1] = checkval>>8;
            *retlen =  checksum + PROTOCAL_HEAD_LENGTH + PROTOCAL_CHECKSUM_LENGTH;

            buflen = 1;
        }
        break;
    case CFG_COMMAND_TESTENVIROMENT:
        { //ADC,temprature,...
            memset((void*)retbuf,0,MAX_MESSAGE_LEN);
            switch( buf[PROTOCAL_DATASTART_INDEX])
            {
            case 1:
                checksum = 6;
                //Build response
                memset(retbuf, 0, MAX_MESSAGE_LEN);
                retbuf[PROTOCAL_START_INDEX] = PROTOCAL_HEAD_FLAG;
                checkval = checksum + PROTOCAL_CHECKSUM_LENGTH + 1;
                retbuf[PROTOCAL_LENLOW_INDEX] = checkval;
                retbuf[PROTOCAL_LENHIGH_INDEX] = checkval>>8;
                retbuf[PROTOCAL_CMD_INDEX] = CFG_COMMAND_TESTENVIROMENT;

                retbuf[PROTOCAL_DATASTART_INDEX+0] = 1;
                retbuf[PROTOCAL_DATASTART_INDEX+1] = 1;
                retbuf[PROTOCAL_DATASTART_INDEX+2] = powerVoltage.dcInputVoltage;
                retbuf[PROTOCAL_DATASTART_INDEX+3] = powerVoltage.dcInputVoltage >> 8;
                retbuf[PROTOCAL_DATASTART_INDEX+4] = powerVoltage.batteryVoltage;
                retbuf[PROTOCAL_DATASTART_INDEX+5] = powerVoltage.batteryVoltage >> 8;

                checkval = CalculateCRC16(retbuf, checksum + PROTOCAL_HEAD_LENGTH);
                retbuf[checksum + PROTOCAL_HEAD_LENGTH] = checkval;
                retbuf[checksum + PROTOCAL_HEAD_LENGTH + 1] = checkval>>8;
                *retlen =  checksum + PROTOCAL_HEAD_LENGTH + PROTOCAL_CHECKSUM_LENGTH;
                buflen = 1;
                break;
            default:
                *retlen = 0;
                buflen = 0;
                break;
            }
        }
        break;
    case CFG_COMMAND_WRITEINFORMATION://AP SSID
        {
            buflen = (uint16_t)(buf[PROTOCAL_LENLOW_INDEX]+((buf[PROTOCAL_LENHIGH_INDEX]&0x0f)<<8));
            buflen = buflen - PROTOCAL_CHECKSUM_LENGTH - 1;
            buflen = SaveInformation(buf+PROTOCAL_DATASTART_INDEX, buflen);

            //Build response
            BuildSettingResponse(CFG_COMMAND_WRITEINFORMATION, buflen, retbuf, retlen);

            buflen = 1;
        }
        break;

    case CFG_COMMAND_WRITEBLSTART:
    {
        writeMemoryStatus.fileAddress = IAP_ADDRESS;
        ubConvert.u8Data[0] = buf[PROTOCAL_DATASTART_INDEX+0];
        ubConvert.u8Data[1] = buf[PROTOCAL_DATASTART_INDEX+1];
        ubConvert.u8Data[2] = buf[PROTOCAL_DATASTART_INDEX+2];
        ubConvert.u8Data[3] = buf[PROTOCAL_DATASTART_INDEX+3];
        writeMemoryStatus.fileTotalLength = ubConvert.u32Data;
        ubConvert.u8Data[0] = buf[PROTOCAL_DATASTART_INDEX+4];
        ubConvert.u8Data[1] = buf[PROTOCAL_DATASTART_INDEX+5];
        ubConvert.u8Data[2] = buf[PROTOCAL_DATASTART_INDEX+6];
        ubConvert.u8Data[3] = buf[PROTOCAL_DATASTART_INDEX+7];
        writeMemoryStatus.datapackLength = ubConvert.u32Data;
        writeMemoryStatus.fileLength = 0;
        writeMemoryStatus.datapackIndex = 0;

        ClearFlashWriteProtect();

        rx = EraseFlashProgram(writeMemoryStatus.fileAddress, writeMemoryStatus.fileTotalLength);
        if( rx > 0)
        {
            rx = 6;
            retbuf[PROTOCAL_START_INDEX] = PROTOCAL_HEAD_FLAG;
            checksum = rx+PROTOCAL_CHECKSUM_LENGTH+1;
            retbuf[PROTOCAL_LENLOW_INDEX] = checksum;
            retbuf[PROTOCAL_LENHIGH_INDEX] = checksum>>8;
            retbuf[PROTOCAL_CMD_INDEX] = CFG_COMMAND_WRITEBLSTART;

            ubConvert.u32Data = writeMemoryStatus.datapackIndex;
            retbuf[PROTOCAL_DATASTART_INDEX+0] = ubConvert.u8Data[0];
            retbuf[PROTOCAL_DATASTART_INDEX+1] = ubConvert.u8Data[1];
            retbuf[PROTOCAL_DATASTART_INDEX+2] = ubConvert.u8Data[2];
            retbuf[PROTOCAL_DATASTART_INDEX+3] = ubConvert.u8Data[3];
            checkval = CalculateCRC16(retbuf, rx + PROTOCAL_HEAD_LENGTH);
            retbuf[rx+PROTOCAL_HEAD_LENGTH] = checkval;
            retbuf[rx+PROTOCAL_HEAD_LENGTH + 1] = checkval>>8;
            *retlen = rx+PROTOCAL_HEAD_LENGTH + PROTOCAL_CHECKSUM_LENGTH;

            writeMemoryStatus.fileAddress = IAP_ADDRESS;

            int tLen = sprintf((char*)dbgBuffer,"CFG_COMMAND_WRITEBLSTART FileTotLength=%d\n", writeMemoryStatus.fileTotalLength);
            ReportMessage(dbgBuffer,tLen);
            retval=1;
        }
    }
    break;

    case CFG_COMMAND_WRITEBLMEMORY:
    {
        ubConvert.u8Data[0] = buf[PROTOCAL_DATASTART_INDEX+0];
        ubConvert.u8Data[1] = buf[PROTOCAL_DATASTART_INDEX+1];
        ubConvert.u8Data[2] = buf[PROTOCAL_DATASTART_INDEX+2];
        ubConvert.u8Data[3] = buf[PROTOCAL_DATASTART_INDEX+3];
        writeMemoryStatus.datapackIndex = ubConvert.u32Data;

        writeMemoryStatus.fileAddress = IAP_ADDRESS + writeMemoryStatus.datapackIndex * writeMemoryStatus.datapackLength;
        if(writeMemoryStatus.datapackIndex * writeMemoryStatus.datapackLength + datalen - 4 <= writeMemoryStatus.fileTotalLength )
        {
            rx = WriteData2FlashProgram(writeMemoryStatus.fileAddress, buf + PROTOCAL_DATASTART_INDEX + 4, datalen - 4 );
            if(rx>0)
            {
                writeMemoryStatus.fileLength = writeMemoryStatus.datapackIndex * writeMemoryStatus.datapackLength + datalen - 4;

                rx=8;
                retbuf[PROTOCAL_START_INDEX] = PROTOCAL_HEAD_FLAG;
                checksum = rx+PROTOCAL_CHECKSUM_LENGTH+1;
                retbuf[PROTOCAL_LENLOW_INDEX] = checksum;
                retbuf[PROTOCAL_LENHIGH_INDEX] = checksum>>8;
                retbuf[PROTOCAL_CMD_INDEX] = CFG_COMMAND_WRITEBLMEMORY;

                ubConvert.u32Data = writeMemoryStatus.datapackIndex;
                retbuf[PROTOCAL_DATASTART_INDEX + 0] = ubConvert.u8Data[0];
                retbuf[PROTOCAL_DATASTART_INDEX + 1] = ubConvert.u8Data[1];
                retbuf[PROTOCAL_DATASTART_INDEX + 2] = ubConvert.u8Data[2];
                retbuf[PROTOCAL_DATASTART_INDEX + 3] = ubConvert.u8Data[3];
                ubConvert.u32Data = writeMemoryStatus.fileLength;
                retbuf[PROTOCAL_DATASTART_INDEX + 4] = ubConvert.u8Data[0];
                retbuf[PROTOCAL_DATASTART_INDEX + 5] = ubConvert.u8Data[1];
                retbuf[PROTOCAL_DATASTART_INDEX + 6] = ubConvert.u8Data[2];
                retbuf[PROTOCAL_DATASTART_INDEX + 7] = ubConvert.u8Data[3];

                checkval = CalculateCRC16(retbuf, rx + PROTOCAL_HEAD_LENGTH);
                retbuf[rx+PROTOCAL_HEAD_LENGTH] = checkval;
                retbuf[rx+PROTOCAL_HEAD_LENGTH + 1] = checkval>>8;
                *retlen = rx+PROTOCAL_HEAD_LENGTH + PROTOCAL_CHECKSUM_LENGTH;

                int tLen = sprintf((char*)dbgBuffer,"CFG_COMMAND_WRITEBLMEMORY %d\n", writeMemoryStatus.datapackIndex);
                ReportMessage(dbgBuffer,tLen);
                
                //writeMemoryStatus.datapackIndex++;
                retval=1;
            }
            else
            {
                retval=1;
            }
        }
        else
        {
            rx=8;
            retbuf[PROTOCAL_START_INDEX] = PROTOCAL_HEAD_FLAG;
            checksum = rx + PROTOCAL_CHECKSUM_LENGTH + 1;
            retbuf[PROTOCAL_LENLOW_INDEX] = checksum;
            retbuf[PROTOCAL_LENHIGH_INDEX] = checksum>>8;
            retbuf[PROTOCAL_CMD_INDEX] = CFG_COMMAND_WRITEBLMEMORY;

            ubConvert.u32Data = 0xffffffff;
            retbuf[PROTOCAL_DATASTART_INDEX + 0] = ubConvert.u8Data[0];
            retbuf[PROTOCAL_DATASTART_INDEX + 1] = ubConvert.u8Data[1];
            retbuf[PROTOCAL_DATASTART_INDEX + 2] = ubConvert.u8Data[2];
            retbuf[PROTOCAL_DATASTART_INDEX + 3] = ubConvert.u8Data[3];
            ubConvert.u32Data = writeMemoryStatus.fileLength;
            retbuf[PROTOCAL_DATASTART_INDEX + 4] = ubConvert.u8Data[0];
            retbuf[PROTOCAL_DATASTART_INDEX + 5] = ubConvert.u8Data[1];
            retbuf[PROTOCAL_DATASTART_INDEX + 6] = ubConvert.u8Data[2];
            retbuf[PROTOCAL_DATASTART_INDEX + 7] = ubConvert.u8Data[3];

            checkval = CalculateCRC16(retbuf, rx + PROTOCAL_HEAD_LENGTH);
            retbuf[rx+PROTOCAL_HEAD_LENGTH] = checkval;
            retbuf[rx+PROTOCAL_HEAD_LENGTH + 1] = checkval>>8;
            *retlen = rx+PROTOCAL_HEAD_LENGTH + PROTOCAL_CHECKSUM_LENGTH;
            retval=1;
        }
    }
    break;

    case CFG_COMMAND_WRITEBLFINISH:
    {
        checksum = (uint16_t)(buf[PROTOCAL_DATASTART_INDEX + 0] + (buf[PROTOCAL_DATASTART_INDEX + 1]<<8));
        checkval = CalculateCRC16((uint8_t*)IAP_ADDRESS, writeMemoryStatus.fileTotalLength);
        rx = (checksum == checkval);

        FinishFlashProgram(IAP_ADDRESS, writeMemoryStatus.fileTotalLength);

        SetFlashWriteProtect();

        int tLen = sprintf((char*)dbgBuffer,"CFG_COMMAND_WRITEBLFINISH chksum=%d, chkval=%d\n, totLen=%d, len=%d", checksum, checkval, writeMemoryStatus.fileTotalLength, writeMemoryStatus.fileLength);
        ReportMessage(dbgBuffer,tLen);

        datalen = 6;
        retbuf[PROTOCAL_START_INDEX] = PROTOCAL_HEAD_FLAG;
        checksum = datalen + PROTOCAL_CHECKSUM_LENGTH + 1;
        retbuf[PROTOCAL_LENLOW_INDEX] = checksum;
        retbuf[PROTOCAL_LENHIGH_INDEX] = checksum>>8;
        retbuf[PROTOCAL_CMD_INDEX] = CFG_COMMAND_WRITEBLFINISH;

        ubConvert.u32Data = writeMemoryStatus.fileLength;
        retbuf[PROTOCAL_DATASTART_INDEX + 0] = ubConvert.u8Data[0];
        retbuf[PROTOCAL_DATASTART_INDEX + 1] = ubConvert.u8Data[1];
        retbuf[PROTOCAL_DATASTART_INDEX + 2] = ubConvert.u8Data[2];
        retbuf[PROTOCAL_DATASTART_INDEX + 3] = ubConvert.u8Data[3];
        retbuf[PROTOCAL_DATASTART_INDEX + 4] = (rx);
        retbuf[PROTOCAL_DATASTART_INDEX + 5] = (rx >> 8);

        checkval = CalculateCRC16(retbuf, datalen + PROTOCAL_HEAD_LENGTH);
        retbuf[datalen+PROTOCAL_HEAD_LENGTH] = checkval;
        retbuf[datalen+PROTOCAL_HEAD_LENGTH + 1] = checkval>>8;
        *retlen = datalen+PROTOCAL_HEAD_LENGTH + PROTOCAL_CHECKSUM_LENGTH;
        retval=1;
    }
    break;

    default:
        buflen=0;
        break;
    }
    if(buflen == 0)
    {//Failed: unsupported command
        return -3;
    }
    else
    {
        return 1;
    }
}
#endif


void ClearReceiveBuffer(void)
{
    memset((void*)&rxBufState, 0, sizeof(stBufferState));
    rxBufState.maxlen = MAX_MESSAGE_LEN;
}

void ProtocalRun(void)
{
    static uint32_t prtState=0;
    uint32_t len = 0;
    int32_t retval = 0;
    //uint8_t i=0, j=0;
    switch(prtState)
    {
    case 0:
        ClearReceiveBuffer();

        //RX
        SET_BIT(CONFIG_UART->CR1, USART_CR1_RE);

        // Enable the UART Error Interrupt: (Frame error, noise error, overrun error)
        SET_BIT(CONFIG_UART->CR3, USART_CR3_EIE);
        // Enable the UART Parity Error and Data Register not empty Interrupts
        SET_BIT(CONFIG_UART->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);

        rxBufState.state = 1;

        prtState=1;
    case 1:
        retval = DataPackageHeadHandler((uint8_t*)rxBufState.buffer, rxBufState.len);
        if(retval < 0)
        {//Failed
            //prtState=0;
            ClearReceiveBuffer();

            rxBufState.state = 0;
        }
        else if(retval > 0)
        {
            prtState=2;
        }
        else
        {
            if( resetFlag )
            {
                BSP_Reboot();
            }
        }
        break;
    case 2:
        retval = DataPackageCompleteHandler((uint8_t*)rxBufState.buffer, rxBufState.len, tempBuf, &len);
        if(retval < 0)
        { //Failed
            ClearReceiveBuffer();
            prtState = 1;

            if(len>0)
            {
                ReportMessage(tempBuf, len);
            }

            rxBufState.state = 0;
        }
        else if(retval > 0)
        {
            //prtState = 4;
            ClearReceiveBuffer();

            prtState = 1;

            ReportMessage(tempBuf, len);

            rxBufState.state = 0;
        }
        break;
    case 3:
        if(txBufState.state==0)
        {
            CLEAR_BIT(CONFIG_UART->CR1, USART_CR1_TCIE);
            CLEAR_BIT(CONFIG_UART->CR1, USART_CR1_TXEIE);
            prtState=0;
        }
        break;

    case 4:
    default:
        prtState=0;
        break;
    }
}

#if 0
void DebugRun(void)
{
    static uint8_t index=0;//
    uint8_t j=0;
    uint32_t temp=0;
    if(txBufState.state>0)//a frame ends!!
    {
        return ;
    }

    j = index;
    do
    {
        temp=0x0001<<index;
        if(0 < debugBufferFlag & temp)
        {
            memset(&txBufState,0,sizeof(stBufferState));
            memcpy((uint8_t*)txBufState.buffer,debugBufferArray[index].buffer,debugBufferArray[index].len);
            txBufState.len=debugBufferArray[index].len;

            txBufState.state=1;//start send

            /* Enable the UART Transmit data register empty Interrupt */
            SET_BIT(CONFIG_UART->CR1, USART_CR1_TE);
            //CLEAR_BIT(CONFIG_UART->CR1, USART_CR1_TCIE);
            SET_BIT(CONFIG_UART->CR1, USART_CR1_TXEIE);

            temp=~temp;
            debugBufferFlag &=temp;

            index++;//find
            break;
        }
        if(++index >= MAX_BUF_COUNT)//next
            index=0;
    }while(j != index);
}

void DebugMessage(uint8_t* msg)
{
    ReportMessage(msg, strlen(msg));
}

void ReportMessage(uint8_t* msg, uint32_t len)
{
    uint8_t i=0;
    uint32_t temp=0;
    for(i=0; i<MAX_BUF_COUNT; i++)
    {
        temp=0x0001<<i;
        if(0 == debugBufferFlag & temp)
        {
            break;
        }
    }

    debugBufferArray[i].len=len;
    if(len>MAX_MESSAGE_LEN)
    {
        memcpy(debugBufferArray[i].buffer,msg,MAX_MESSAGE_LEN);
    }
    else
    {
        memcpy(debugBufferArray[i].buffer,msg,len);
    }
    debugBufferFlag |= temp;

    DebugRun();
}
#else
void DebugRun(void)
{
    //static uint8_t index=0;//
    //uint8_t j=0;
    //uint32_t temp=0;
    if(txBufState.state>0)//a frame ends!!
    {
        return ;
    }
    if(debugStatus.msgSlots[debugStatus.index].flag == 1)
    {//have message to be sent
        //debugStatus.status = 1;

        memset((void*)&txBufState,0,sizeof(stBufferState));
        txBufState.len = debugStatus.msgSlots[debugStatus.index].len;
        memcpy((void*)(txBufState.buffer),(const void*)(debugStatus.msgSlots[debugStatus.index].message),
               txBufState.len);

        txBufState.state=1;//start send

        // Enable the UART Transmit data register empty Interrupt
        SET_BIT(CONFIG_UART->CR1, USART_CR1_TE);
        //CLEAR_BIT(CONFIG_UART->CR1, USART_CR1_TCIE);
        SET_BIT(CONFIG_UART->CR1, USART_CR1_TXEIE);

        //
        debugStatus.msgSlots[debugStatus.index].len = 0;
        debugStatus.msgSlots[debugStatus.index].flag = 0;

        debugStatus.index++;
        if(debugStatus.index>=MESSAGE_SLOT_COUNT)
            debugStatus.index=0;

        debugStatus.count--;

        //debugStatus.status = 0;
    }
}

void DebugMessage(uint8_t* msg)
{
    ReportMessage(msg, strlen((const char*)msg));
}

void ReportMessage(uint8_t* msg, uint32_t len)
{
    if(len < 2 || ((debugStatus.index == debugStatus.tail) && (debugStatus.count >= MESSAGE_SLOT_COUNT)) )
    {
        return;
    }

    uint32_t curIdx=debugStatus.tail;
    debugStatus.tail++;
    if(debugStatus.tail>=MESSAGE_SLOT_COUNT)
    {
        debugStatus.tail=0;
    }
    if(len > MAX_MESSAGE_LEN)
    {
        len = MAX_MESSAGE_LEN;
    }
    memcpy((void*)&debugStatus.msgSlots[curIdx].message[0], msg, len);
    debugStatus.msgSlots[curIdx].flag = 1;
    debugStatus.msgSlots[curIdx].len = len;
    debugStatus.count++;

    DebugRun();
}

void ReportString(uint8_t* msg)
{
    ReportMessage(msg, strlen((const char*)msg));
}
#endif

/**
* @brief  Retargets the C library printf function to the USART.
* @param  None
* @retval None
*/
#ifdef __GNUC__
/* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf set to 'Yes') calls __io_putchar() */
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /* __GNUC__ */
PUTCHAR_PROTOTYPE
{
    HAL_UART_Transmit(&debug_UartHandle, (uint8_t *)&ch, 1, 0xFFFF);
    return ch;
}

#define __UART_GET_FLAG(__UART__, __FLAG__)     (((__UART__)->SR & (__FLAG__)) == (__FLAG__))
#define __UART_CLEAR_FLAG(__UART__, __FLAG__)   ((__UART__)->SR = ~(__FLAG__))
void Debug_Uart_IRQ_Handler(void)
{
    uint32_t isr     = READ_REG(CONFIG_UART->SR);//
    uint32_t cr1    = READ_REG(CONFIG_UART->CR1);
    uint32_t cr3    = READ_REG(CONFIG_UART->CR3);
	uint16_t ucCh   = (uint16_t)(READ_REG(CONFIG_UART->DR) & 0x00FF);//8BIT data, No PARITY
    uint32_t errorflags = 0x00U;
    uint32_t ErrorCode = 0x00U;
    /* If no error occurs */
    errorflags = (isr & (uint32_t)(USART_SR_PE | USART_SR_FE | USART_SR_ORE | USART_SR_NE));
    if(errorflags == RESET)
    {
        /* UART in mode Receiver -------------------------------------------------*/
        if(((isr & USART_SR_RXNE) != RESET) && ((cr1 & USART_CR1_RXNEIE) != RESET))
        {
            //__UART_CLEAR_FLAG( CONFIG_UART, UART_FLAG_RXNE );

            rxBufState.buffer[rxBufState.index++] = (uint8_t)ucCh;
            rxBufState.len++;
            if((rxBufState.index) >= rxBufState.maxlen)
            {
                rxBufState.index=0;
            }
            return;
        }
    }

    /* If some errors occur */
    if((errorflags != RESET) && (((cr3 & USART_CR3_EIE) != RESET) || ((cr1 & (USART_CR1_RXNEIE | USART_CR1_PEIE)) != RESET)))
    {
        /* UART parity error interrupt occurred ----------------------------------*/
        if(((isr & USART_SR_PE) != RESET) && ((cr1 & USART_CR1_PEIE) != RESET))
        {
            ErrorCode |= HAL_UART_ERROR_PE;
        }

        /* UART noise error interrupt occurred -----------------------------------*/
        if(((isr & USART_SR_NE) != RESET) && ((cr3 & USART_CR3_EIE) != RESET))
        {
            ErrorCode |= HAL_UART_ERROR_NE;
        }

        /* UART frame error interrupt occurred -----------------------------------*/
        if(((isr & USART_SR_FE) != RESET) && ((cr3 & USART_CR3_EIE) != RESET))
        {
            ErrorCode |= HAL_UART_ERROR_FE;
        }

        /* UART Over-Run interrupt occurred --------------------------------------*/
        if(((isr & USART_SR_ORE) != RESET) && ((cr3 & USART_CR3_EIE) != RESET))
        {
            ErrorCode |= HAL_UART_ERROR_ORE;
        }

        /* Call UART Error Call back function if need be --------------------------*/
        if(ErrorCode != HAL_UART_ERROR_NONE)
        {
            /* UART in mode Receiver -----------------------------------------------*/
            if(((isr & USART_SR_RXNE) != RESET) && ((cr1 & USART_CR1_RXNEIE) != RESET))
            {
                rxBufState.buffer[rxBufState.index++] = (uint8_t)ucCh;
                rxBufState.len++;
                if((rxBufState.index) >= rxBufState.maxlen)
                {
                    rxBufState.index=0;
                }
            }
        }
    }
    if((isr & UART_FLAG_IDLE)>0)
    {
        __UART_CLEAR_FLAG( CONFIG_UART, UART_FLAG_IDLE );
    }

    /* UART in mode Transmitter ------------------------------------------------*/
    if(((isr & USART_SR_TXE) != RESET) && ((cr1 & USART_CR1_TXEIE) != RESET))
    {
        CONFIG_UART->DR = (uint8_t)txBufState.buffer[txBufState.index];
        txBufState.index++;
        txBufState.state=1;

        if(txBufState.index >= txBufState.len)
        {
            /* Enable the UART Transmit Complete Interrupt */
            //CLEAR_BIT(CONFIG_UART->CR1, USART_CR1_TCIE);
            /* Disable the UART Transmit Complete Interrupt */
            //SET_BIT(CONFIG_UART->CR1, USART_CR1_TXEIE);

            /* Disable the UART Transmit Complete Interrupt */
            CLEAR_BIT(CONFIG_UART->CR1, USART_CR1_TXEIE);

            /* Enable the UART Transmit Complete Interrupt */
            SET_BIT(CONFIG_UART->CR1, USART_CR1_TCIE);
        }

        isr = CONFIG_UART->SR;
        cr1 = CONFIG_UART->CR1;
    }

    /* UART in mode Transmitter end --------------------------------------------*/
    if(((isr & USART_SR_TC) != RESET) && ((cr1 & USART_CR1_TCIE) != RESET))
    {
        __UART_CLEAR_FLAG( CONFIG_UART, UART_FLAG_TC );

        /* Disable the UART Transmit Complete Interrupt */
        CLEAR_BIT(CONFIG_UART->CR1, USART_CR1_TCIE);

        txBufState.state=0;

        DebugRun();
    }
}