#include "stdio.h"
#include "stdarg.h"
#include "stdlib.h"
#include "string.h"
#include "stm32f4xx_hal.h"
#include "math.h"
#include "HIDO_Util.h"
#include "HIDO_Debug.h"
#include "HIDO_Timer.h"

#include "GPS.h"
#include "DBG.h"
#include "GPIO.h"
#include "Uart.h"
#include "Delay.h"
#include "UDPClient.h"
#include "global_param.h"

#include "TTS.h"

#define GPS_DBG(level, fmt, ...) HIDO_Debug(fmt, __VA_ARGS__)

#define GPS_UART_RX_BUF_SIZE                    1024
#define GPS_UART_TX_BUF_SIZE                    (2048 + 512)

typedef enum
{
    GPS_RECV_STATE_IDLE = 0,
    GPS_RECV_STATE_HEAD,
    GPS_RECV_STATE_CR,
    GPS_RECV_STATE_LF,
} E_GPSRecvState;

typedef struct
{
    E_GPSRecvState m_eState;
    HIDO_CHAR m_acHeader[10],m_acHeader2[10],m_acHeader3[10];
    HIDO_UINT32 m_u32HeaderLen,m_u32Header2Len,m_u32Header3Len;

    HIDO_CHAR m_acRecvBuf[128];
    HIDO_UINT32 m_u32RecvLen;
} ST_GPSRecv;

static HIDO_UINT8 l_au8GPSUartRxBuf[GPS_UART_RX_BUF_SIZE];
static HIDO_UINT8 l_au8GPSUartTxBuf[GPS_UART_TX_BUF_SIZE];

static ST_GPIO l_astGPSPin[GPS_PIN_LAST];
static ST_GPSRecv l_stGPSRecv;

static HIDO_UINT8 l_u8PosState = 0;
static HIDO_UINT8 l_u8GPS_HZ = 0;
static HIDO_BOOL l_bGPSConfig = HIDO_FALSE;
static HIDO_UINT32 l_u32QXTick = 0;
HIDO_UINT32 getRTK_Tick = 0;
/* GPSÃüÁî */
static HIDO_UINT8 l_au8CmdSave[] = { 0xB5, 0x62, 0x06, 0x09, 0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x31, 0xBF };
static HIDO_UINT8 l_au8CmdRate1Hz[] = { 0xB5, 0x62, 0x06, 0x08, 0x06, 0x00, 0xE8, 0x03, 0x01, 0x00, 0x01, 0x00, 0x01, 0x39 };
static HIDO_UINT8 l_au8CmdRate2Hz[] = { 0xB5, 0x62, 0x06, 0x08, 0x06, 0x00, 0xF4, 0x01, 0x01, 0x00, 0x01, 0x00, 0x0B, 0x77 };
static HIDO_UINT8 l_au8CmdRate5Hz[] = { 0xB5, 0x62, 0x06, 0x08, 0x06, 0x00, 0xC8, 0x00, 0x01, 0x00, 0x01, 0x00, 0xDE, 0x6A };
static HIDO_UINT8 l_au8CmdRate10Hz[] = { 0xB5, 0x62, 0x06, 0x08, 0x06, 0x00, 0x64, 0x00, 0x01, 0x00, 0x01, 0x00, 0x7A, 0x12 };

/*******************************************************************************
 * Function Name     : GPS_RateConfig
 * Description       : GPSËÙÂÊÅäÖà ֧³Ö1HZ¡¢2HZ¡¢5HZ¡¢10HZ
 * Input             : _u8Rate ËÙÂÊ
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2021Äê5ÔÂ07ÈÕ
 *******************************************************************************/
static HIDO_INT32 GPS_RateConfig(HIDO_UINT8 _u8Rate)
{
    l_u8GPS_HZ = _u8Rate;

    switch(_u8Rate)
    {
        case 1:
        {
            Uart_Send(UART_ID_GPS, l_au8CmdRate1Hz, sizeof(l_au8CmdRate1Hz));
            Uart_Send(UART_ID_GPS, l_au8CmdSave, sizeof(l_au8CmdSave));
            break;
        }
        case 2:
        {
            Uart_Send(UART_ID_GPS, l_au8CmdRate2Hz, sizeof(l_au8CmdRate2Hz));
            Uart_Send(UART_ID_GPS, l_au8CmdSave, sizeof(l_au8CmdSave));
            break;
        }
        case 5:
        {
            Uart_Send(UART_ID_GPS, l_au8CmdRate5Hz, sizeof(l_au8CmdRate5Hz));
            Uart_Send(UART_ID_GPS, l_au8CmdSave, sizeof(l_au8CmdSave));
            break;
        }
        case 10:
        {
            Uart_Send(UART_ID_GPS, l_au8CmdRate10Hz, sizeof(l_au8CmdRate10Hz));
            Uart_Send(UART_ID_GPS, l_au8CmdSave, sizeof(l_au8CmdSave));
            break;
        }
        default:
        {
            break;
        }
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : GPS_DataCheck
 * Description       : GPSÊý¾Ý¸ñʽ¼ì²é
 * Input             : _pcData GPSÊý¾Ý
 *                   : _u32Len GPSÊý¾Ý³¤¶È
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2021Äê5ÔÂ07ÈÕ
 *******************************************************************************/
static HIDO_INT32 GPS_DataCheck(HIDO_CHAR *_pcData, HIDO_UINT32 _u32Len)
{
    HIDO_DataStruct stData;
    HIDO_DataStruct stCheckValue;
    HIDO_UINT8 u8CheckValue = 0;
    HIDO_UINT8 u8CalcValue = 0;
    HIDO_UINT32 i = 0;

    if(HIDO_UtilParseFormat((HIDO_UINT8 *)_pcData, _u32Len, "$%p*%p\r\n", &stData, &stCheckValue) != 2)
    {
        return HIDO_ERR;
    }

    u8CheckValue = HIDO_UtilHexStrBufToInt((HIDO_CHAR *)stCheckValue.m_pData, stCheckValue.m_u32Len);
    u8CalcValue = ((HIDO_UINT8 *)stData.m_pData)[0];
    for(i = 1; i < stData.m_u32Len; i++)
    {
        u8CalcValue ^= ((HIDO_UINT8 *)stData.m_pData)[i];
    }

    if(u8CalcValue != u8CheckValue)
    {
        return HIDO_ERR;
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : GPS_ParseGGA
 * Description       : GPS GGAÊý¾Ý½âÎö(½ö¼ì²éÊý¾ÝÊÇ·ñÓÐЧ)
 * Input             : _pcData GGAÊý¾Ý
 *                   : _u32Len GGAÊý¾Ý³¤¶È
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2021Äê5ÔÂ07ÈÕ
 *******************************************************************************/
double jd1,wd1;//ÓÃÓÚ´«µÝGNGGAµã¾­Î³¶È
int gps_state;
char utc_time_save[20];
HIDO_DataStruct jd1Recv,wd1Recv,type,stPosState,utcTimeStemp;
static HIDO_INT32 GPS_ParseGGA(HIDO_CHAR *_pcData, HIDO_UINT32 _u32Len)
{
    ST_GPS stGPS;
    
	
    memset(&stGPS, 0, sizeof(ST_GPS));
    if (GPS_DataCheck(_pcData, _u32Len) != HIDO_OK)
    {
        return HIDO_ERR;
    }

//    if (HIDO_UtilParseFormat((HIDO_UINT8 *) _pcData, _u32Len, "$%*,%*,%*,%*,%*,%*,%p,%*,%*,%*,%*,%*,%*,%*,%**", &stPosState) != 15)
//    {
//        return HIDO_ERR;
//    }
				if (HIDO_UtilParseFormat((HIDO_UINT8 *) _pcData, _u32Len,"$%*,%p,%p,%*,%p,%*,%p,%*,%*,%*,%*,%*,%*,%*,%**",&utcTimeStemp,&wd1Recv,&jd1Recv,&stPosState) !=15 )
    {
        return HIDO_ERR;
    }
		l_u8PosState = atoi((HIDO_CHAR *)stPosState.m_pData);//°ÑGNGGAµÄÖÐÊý¾Ý½âÎö³öÀ´×ª»¯¸ø±äÁ¿
		jd1=strtod((HIDO_CHAR *)jd1Recv.m_pData,NULL);//ת»»ÎªdoubleÀàÐ;­Î³¶È×ø±ê
		wd1=strtod((HIDO_CHAR *)wd1Recv.m_pData,NULL);
    l_u8PosState = atoi((HIDO_CHAR *)stPosState.m_pData);
		memcpy(&utc_time_save,utcTimeStemp.m_pData,6);
		gps_state=l_u8PosState;
    return HIDO_OK;
}
u16 g_spsum,g_snum;
static HIDO_INT32 GPS_ParseGSV(HIDO_CHAR *_pcData, HIDO_UINT32 _u32Len)
{
    ST_GPS stGPS;
    HIDO_DataStruct spower[4];

    memset(&stGPS, 0, sizeof(ST_GPS));
//    if (GPS_DataCheck(_pcData, _u32Len) != HIDO_OK)
//    {
//        return HIDO_ERR;
//    }

    if (HIDO_UtilParseFormat((HIDO_UINT8 *) _pcData, _u32Len, "$%*,%*,%*,%*,%*,%*,%*,%p,%*,%*,%*,%p,%*,%*,%*,%p,%*,%*,%*,%p,%**", &spower[0], &spower[1], &spower[2], &spower[3]) == 21)
    {
        g_snum+=4;
        g_spsum+=atoi((HIDO_CHAR *)spower[0].m_pData)+atoi((HIDO_CHAR *)spower[1].m_pData)+atoi((HIDO_CHAR *)spower[2].m_pData)+atoi((HIDO_CHAR *)spower[3].m_pData);
    }else if(HIDO_UtilParseFormat((HIDO_UINT8 *) _pcData, _u32Len, "$%*,%*,%*,%*,%*,%*,%*,%p,%*,%*,%*,%p,%*,%*,%*,%p,%**", &spower[0], &spower[1], &spower[2]) == 17)
    {
         g_snum+=3;
        g_spsum+=atoi((HIDO_CHAR *)spower[0].m_pData)+atoi((HIDO_CHAR *)spower[1].m_pData)+atoi((HIDO_CHAR *)spower[2].m_pData);

    }else if(HIDO_UtilParseFormat((HIDO_UINT8 *) _pcData, _u32Len, "$%*,%*,%*,%*,%*,%*,%*,%p,%*,%*,%*,%p,%**", &spower[0], &spower[1]) == 13)
    {
         g_snum+=2;
        g_spsum+=atoi((HIDO_CHAR *)spower[0].m_pData)+atoi((HIDO_CHAR *)spower[1].m_pData);

    }else if(HIDO_UtilParseFormat((HIDO_UINT8 *) _pcData, _u32Len, "$%*,%*,%*,%*,%*,%*,%*,%p,%**", &spower[0]) == 9)
    {
         g_snum+=1;
        g_spsum+=atoi((HIDO_CHAR *)spower[0].m_pData);

    }
   // l_u8PosState = atoi((HIDO_CHAR *)stPosState.m_pData);

    return HIDO_OK;
}
/*******************************************************************************
 * Function Name     : GPS_RecvFsm
 * Description       : GPS Êý¾Ý½ÓÊÕ״̬»ú
 * Input             : _u8RecvChar Ò»¸ö½ÓÊÕ×Ö·û
 * Output            : None
 * Return            : one
 * Author            : www.hido-studio.com
 * Modified Date:    : 2021Äê5ÔÂ07ÈÕ
 *******************************************************************************/

static HIDO_VOID GPS_RecvFsm(HIDO_UINT8 _u8RecvChar)
{
    static int LastRTK = 0;
    
    HIDO_CHAR GPS_1[10] = "É豸µ¥µã";
    HIDO_CHAR GPS_4[10] = "É豸¹Ì¶¨";
    HIDO_CHAR GPS_5[10] = "É豸¸¡¶¯";
    
    switch (l_stGPSRecv.m_eState)
    {
        case GPS_RECV_STATE_IDLE:
        {
            if ('$' == _u8RecvChar)
            {
                l_stGPSRecv.m_eState = GPS_RECV_STATE_HEAD;
                l_stGPSRecv.m_u32RecvLen = 0;
                l_stGPSRecv.m_acRecvBuf[l_stGPSRecv.m_u32RecvLen++] = _u8RecvChar;
            }
            break;
        }
        case GPS_RECV_STATE_HEAD:
        {
            l_stGPSRecv.m_acRecvBuf[l_stGPSRecv.m_u32RecvLen++] = _u8RecvChar;
            if (l_stGPSRecv.m_u32RecvLen >= l_stGPSRecv.m_u32HeaderLen)
            {
                if (memcmp(l_stGPSRecv.m_acRecvBuf, l_stGPSRecv.m_acHeader, l_stGPSRecv.m_u32HeaderLen) == 0)
                {
                    l_stGPSRecv.m_eState = GPS_RECV_STATE_CR;
                }else if(memcmp(l_stGPSRecv.m_acRecvBuf, l_stGPSRecv.m_acHeader2, l_stGPSRecv.m_u32Header2Len) == 0)
                {
                    l_stGPSRecv.m_eState = GPS_RECV_STATE_CR;
                }else if(memcmp(l_stGPSRecv.m_acRecvBuf, l_stGPSRecv.m_acHeader3, l_stGPSRecv.m_u32Header3Len) == 0)
                {
                    l_stGPSRecv.m_eState = GPS_RECV_STATE_CR;
                }
                else
                {
                    l_stGPSRecv.m_eState = GPS_RECV_STATE_IDLE;
                }
            }

            break;
        }
        case GPS_RECV_STATE_CR:
        {
            l_stGPSRecv.m_acRecvBuf[l_stGPSRecv.m_u32RecvLen++] = _u8RecvChar;

            if (l_stGPSRecv.m_u32RecvLen >= (sizeof(l_stGPSRecv.m_acRecvBuf) - 1))
            {
                l_stGPSRecv.m_eState = GPS_RECV_STATE_IDLE;
                break;
            }

            if ('\r' == _u8RecvChar)
            {
                l_stGPSRecv.m_eState = GPS_RECV_STATE_LF;
            }

            break;
        }
        case GPS_RECV_STATE_LF:
        {static u8 gpsled_state=0;
            l_stGPSRecv.m_acRecvBuf[l_stGPSRecv.m_u32RecvLen++] = _u8RecvChar;
            if ('\n' == _u8RecvChar)
            {
              
                /* ÅäÖÃGPS HZ */
//                g_com_map[GPS_HZ] = 10;
                if(l_bGPSConfig || l_u8GPS_HZ != g_com_map[GPS_HZ])
                {
                    l_bGPSConfig = HIDO_FALSE;
                    GPS_RateConfig(g_com_map[GPS_HZ]);
                }

                

                
                if (memcmp(l_stGPSRecv.m_acRecvBuf, l_stGPSRecv.m_acHeader3, l_stGPSRecv.m_u32Header3Len) == 0)
                {
                    GPS_ParseGSV(l_stGPSRecv.m_acRecvBuf, l_stGPSRecv.m_u32RecvLen);
                }
                if (memcmp(l_stGPSRecv.m_acRecvBuf, l_stGPSRecv.m_acHeader, l_stGPSRecv.m_u32HeaderLen) == 0)
                {
                    GPS_ParseGGA(l_stGPSRecv.m_acRecvBuf, l_stGPSRecv.m_u32RecvLen);
                    l_stGPSRecv.m_acRecvBuf[l_stGPSRecv.m_u32RecvLen - 2] = '\0';
                    //UDPClient_UploadGPS(l_stGPSRecv.m_acRecvBuf);
            if(gpsled_state)
                {
                    gpsled_state = 0;
                    rtkled = LEDOFF;
                    Set4LEDColor(uwbled,rtkled,led4g,powerled);
                }else{
                    gpsled_state = 1;
                    
                    
                        if(LastRTK != l_u8PosState)   //µ±RTK״̬·¢Éú±ä»¯Ê±£¬½øÐÐÓïÒô²¥±¨
                        {
                             switch(l_u8PosState)
                             {
//                                case 1:
//                                    TTS_Play((HIDO_UINT8 *)GPS_1, strlen(GPS_1));									
//                                    break;
                                case 4:
                                    TTS_Play((HIDO_UINT8 *)GPS_4, strlen(GPS_4));									
                                    break;
//                                case 5:
//                                    TTS_Play((HIDO_UINT8 *)GPS_5, strlen(GPS_5));									
//                                    break;
                             }
                        }                    
                    
                    
                    
                 switch(l_u8PosState)
                    {
                        case 0:
                            rtkled = RED;
                            break;
                        case 1:
                            rtkled = BLUE; 
                            break;
                        case 2:
                            rtkled = BLUE+GREEN; 
                            break;
                        case 4:
                            rtkled = GREEN; 
                            break;
                        case 5:
                            rtkled = YELLOW; 
                            break;
                        default:
                            rtkled = WHITE; 
                            break;
                    } 
                    //g_Resttimer=0;                    
                    Set4LEDColor(uwbled,rtkled,led4g,powerled);        

                    LastRTK = l_u8PosState;   //¼Ç¼RTK״̬                         
                }
                }
                if((HIDO_TimerGetTick() - l_u32QXTick) >= 1000)
                {
                    l_u32QXTick = HIDO_TimerGetTick();
#ifdef __USE_QXWZ__
                    qxwz_app_upload_gga(l_stGPSRecv.m_acRecvBuf);
#endif
                }
        
            }

            l_stGPSRecv.m_eState = GPS_RECV_STATE_IDLE;
            break;
        }
        default:
        {
            break;
        }
    }
}

/*******************************************************************************
 * Function Name     : GPS_Rest
 * Description       : GPS¸´Î»
 * Input             : None
 * Output            : None
 * Return            : None
 * Author            : www.hido-studio.com
 * Modified Date:    : 2021Äê1ÔÂ8ÈÕ
 *******************************************************************************/
static HIDO_VOID GPS_Rest(void)
{
    GPIO_SET(&l_astGPSPin[GPS_PIN_REST]);
    HAL_Delay(10);
    GPIO_RESET(&l_astGPSPin[GPS_PIN_REST]);
    HAL_Delay(10);
    GPIO_SET(&l_astGPSPin[GPS_PIN_REST]);
}

/*******************************************************************************
 * Function Name     : GPS_PowerOn
 * Description       : GPSÉϵç
 * Input             : None
 * Output            : None
 * Return            : None
 * Author            : www.hido-studio.com
 * Modified Date:    : 2021Äê1ÔÂ8ÈÕ
 *******************************************************************************/
static HIDO_VOID GPS_PowerOn(void)
{
    GPIO_SET(&l_astGPSPin[GPS_PIN_EN]);
}

/*******************************************************************************
 * Function Name     : GPS_PowerOff
 * Description       : GPSµôµç
 * Input             : None
 * Output            : None
 * Return            : None
 * Author            : www.hido-studio.com
 * Modified Date:    : 2021Äê1ÔÂ8ÈÕ
 *******************************************************************************/
HIDO_VOID GPS_PowerOff(void)
{
    GPIO_RESET(&l_astGPSPin[GPS_PIN_EN]);
}

/*******************************************************************************
 *                             Global Function                                 *
 *******************************************************************************/

/*******************************************************************************
 * Function Name     : GPS_GetState
 * Description       : »ñÈ¡GPS¶¨Î»×´Ì¬
 * Input             : None
 * Output            : None
 * Return            : ¶¨Î»×´Ì¬ 0 1 2 3
 * Author            : www.hido-studio.com
 * Modified Date:    : 2021Äê1ÔÂ8ÈÕ
 *******************************************************************************/
HIDO_UINT8 GPS_GetState(HIDO_VOID)
{
    return l_u8PosState;
}

/*******************************************************************************
 * Function Name     : GPS_PinRegister
 * Description       : GPSÄ£¿é¹Ü½Å×¢²á
 * Input             : _ePin ¹Ü½Å¶¨Òå
 *                   : _pstGPIOx GPIOx
 *                   : _u16GPIOPin GPIO_PIN_x
 * Output            : None
 * Return            : None
 * Author            : www.hido-studio.com
 * Modified Date:    : 2021Äê1ÔÂ8ÈÕ
 *******************************************************************************/
HIDO_VOID GPS_PinRegister(E_GPSPin _ePin, GPIO_TypeDef* _pstGPIOx, HIDO_UINT16 _u16GPIOPin)
{
    l_astGPSPin[_ePin].m_pstGPIOx = _pstGPIOx;
    l_astGPSPin[_ePin].m_u16GPIOPin = _u16GPIOPin;
}

/*******************************************************************************
 * Function Name     : GPS_Poll
 * Description       : GPSÂÖѯ´¦Àí
 * Input             : None
 * Output            : None
 * Return            : None
 * Author            : www.hido-studio.com
 * Modified Date:    : 2021Äê1ÔÂ8ÈÕ
 *******************************************************************************/
HIDO_VOID GPS_Poll(void)
{
    static HIDO_UINT8 l_u8GPSBuff[512];
    static HIDO_UINT32 l_u8GPSLen = 0;
    static HIDO_UINT32 l_u8GPSRecvTick = 0;

    volatile HIDO_INT32 i32Result = HIDO_OK;
    HIDO_UINT8 u8RecvChar = 0;
    UART_HandleTypeDef *pstUartHandle = HIDO_NULL;

    Uart_GetHandle(UART_ID_DBG, (HIDO_VOID **)&pstUartHandle);

    while ((i32Result = Uart_GetChar(UART_ID_GPS, &u8RecvChar)) == HIDO_OK)
    {
        if(DBG_GetMode() == DBG_MODE_GPS||DBG_GetMode() == DBG_MODE_CFG)
        {
            HAL_UART_Transmit(pstUartHandle, &u8RecvChar, 1, 1000);
        }
        GPS_RecvFsm(u8RecvChar);
        l_u8GPSBuff[l_u8GPSLen++] = u8RecvChar;
        if(l_u8GPSLen >= sizeof(l_u8GPSBuff))
        {
#ifdef __USE_TCP_RTCM__
            RTKClient_ReportData(l_u8GPSBuff, l_u8GPSLen);
#endif
#ifdef __USE_NTRIP__
            NTRIPApp_ReportGGA(l_u8GPSBuff, l_u8GPSLen);
#endif
            l_u8GPSLen = 0;
        }
        
        l_u8GPSRecvTick = HIDO_TimerGetTick();
    }

    if(l_u8GPSLen > 0)
    {
        if((HIDO_TimerGetTick() - l_u8GPSRecvTick) > 50)
        {
#ifdef __USE_TCP_RTCM__
            RTKClient_ReportData(l_u8GPSBuff, l_u8GPSLen);
#endif
#ifdef __USE_NTRIP__
            NTRIPApp_ReportGGA(l_u8GPSBuff, l_u8GPSLen);
#endif
            l_u8GPSLen = 0;
        }
    }
}

/*******************************************************************************
 * Function Name     : GPS_Init
 * Description       : GPSÄ£¿é³õʼ»¯
 * Input             : None
 * Output            : None
 * Return            : None
 * Author            : www.hido-studio.com
 * Modified Date:    : 2021Äê1ÔÂ8ÈÕ
 *******************************************************************************/
HIDO_VOID GPS_Init(void)
{
    uint32_t gpsbaudrate;
    GPS_PowerOn();
    GPS_Rest();

    ST_UartInit stInit;

    stInit.m_eRxMode = UART_RX_MODE_DMA;
    stInit.m_eTxMode = UART_TX_MODE_DMA;
    stInit.m_pu8RxBuf = l_au8GPSUartRxBuf;
    stInit.m_u32RxBufSize = GPS_UART_RX_BUF_SIZE;
    stInit.m_pu8TxBuf = l_au8GPSUartTxBuf;
    stInit.m_u32TxBufSize = GPS_UART_TX_BUF_SIZE;
    stInit.m_u32TxQueueMemberCnt = 2;
    Uart_Init(UART_ID_GPS, &stInit);

    HIDO_UtilBzero(&l_stGPSRecv, sizeof(ST_GPSRecv));
    l_stGPSRecv.m_u32HeaderLen = HIDO_UtilSnprintf(l_stGPSRecv.m_acHeader, sizeof(l_stGPSRecv.m_acHeader), "$GNGGA");
    l_stGPSRecv.m_u32Header2Len = HIDO_UtilSnprintf(l_stGPSRecv.m_acHeader2, sizeof(l_stGPSRecv.m_acHeader2), "$GPGSV");
    l_stGPSRecv.m_u32Header3Len = HIDO_UtilSnprintf(l_stGPSRecv.m_acHeader3, sizeof(l_stGPSRecv.m_acHeader3), "$GBGSV");
    l_bGPSConfig = HIDO_TRUE; 
    gpsbaudrate = (g_com_map[GPSBAUDRATE1_INDEX]<<8)|g_com_map[GPSBAUDRATE2_INDEX];
    if(gpsbaudrate>921600||gpsbaudrate<9600)
    {
        gpsbaudrate = 115200;
    }   
    Uart_ReConfigBaudRate(UART_ID_GPS,gpsbaudrate);
}