开发差不多完成，等新板子来了测一下充电跟休眠那块的逻辑。目前4g跟gps上传那块跟urtf4的差不多。

WXK

2025-02-24 cc919e4e5e2395b61b86f922a07440f47ae2ad0a

 keil/include/src/gps.c

@@ -1,148 +1,846 @@
#include "board.h"
#include "stdio.h"
#include "stdarg.h"
#include "stdlib.h"
#include "string.h"
//#include "stm32l0xx_hal.h"
#include "math.h"
#include "HIDO_Util.h"
#include "global_param.h"
#define GPS_OPEN_TIME_OUT  48      //1分钟开启
#define GPS_RESTART_TIME1  480  //10分钟
#define GPS_RESTART_TIME2  48      //1分钟
#define GPS_RESTART_TIME3  30      //30s
extern uint16_t gps_wait_count,g_com_map[COM_MAP_SIZE];
extern uint8_t flag_first_TCPconnect;
extern uint16_t gps_wait_count2;
uint16_t g_spsum,g_snum,ave_sp;
uint8_t gps_power_state,gps_uwb_flag,gps_4g_flag,gps_timeout_flag,gps_need_data_flag = 1,gps_open_flag;
void GPS_Poll(void)
{
#include "HIDO_Debug.h"
#include "HIDO_Timer.h"

    if(gps_4g_flag||gps_uwb_flag) {
        gps_power_state = 1;  //打开GPS电源
        if(!gps_timeout_flag) {
            if(gps_need_data_flag) {
                gps_wait_count++;
                if(gps_wait_count>=GPS_OPEN_TIME_OUT) { //超时切换工作状态
                    gps_timeout_flag=1;//串口添加改变timeout逻辑
                    gps_wait_count=0;
                    gps_need_data_flag=0;//切换为关闭模式
                }
            } else {
                gps_wait_count++;
                gps_power_state=0;//关闭GPS
                if(gps_wait_count>GPS_RESTART_TIME2) {
                    gps_power_state=1;//开启GPS
                    gps_need_data_flag=1;
                    gps_wait_count=0;
                }
            }
        } else { //超时工作状态
            if(gps_need_data_flag) {
                gps_wait_count++;
                if(gps_wait_count>=GPS_OPEN_TIME_OUT) { //超时切换工作状态
                    gps_timeout_flag=1;
                    gps_need_data_flag=0;
                    gps_wait_count=0;
                }
            } else {
                gps_wait_count++;
                gps_power_state=0;//关闭GPS
                if(gps_wait_count>GPS_RESTART_TIME1) {
                    gps_power_state=1;//开启GPS
                    gps_need_data_flag=1;
                    gps_wait_count=0;
                }
            }
#include "GPS.h"
//#include "GPIO.h"
#include "Uart.h"
#include "WS2812.h"
#define GPS_DBG(level, fmt, ...) HIDO_Debug(fmt, __VA_ARGS__)

        }
    } else {
        gps_power_state=0;//关闭gps
        gps_wait_count=0;
        gps_timeout_flag=0;
        gps_need_data_flag=1;
    }
}
void GpsConrol(uint8_t flag_4g_uwb,uint8_t open_close)
#define GPS_UART_RX_BUF_SIZE                    1024
#define GPS_UART_TX_BUF_SIZE                    (4)

typedef enum
{
    if(gps_4g_flag==0&&gps_uwb_flag==0)
        if(open_close)
    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_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 HIDO_BOOL l_bIsPowerOn = HIDO_FALSE;
static ST_GPSRecv l_stGPSRecv;
static FN_GPSEventCallback l_fnGPSEventCallback;
ST_GPS l_stGPS;

/*******************************************************************************
 * Function Name     : GPS_AddHours
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : wx:duj_an
 * Modified Date:    : 2021年1月8日
 *******************************************************************************/
static void GPS_AddHours(ST_GPS *_pstGPS, HIDO_UINT32 _u32Hours)
{
    _pstGPS->m_u8Hour += _u32Hours;
    if (_pstGPS->m_u8Hour >= 24)
    {
        _pstGPS->m_u8Hour -= 24;
        _pstGPS->m_u8Day++;
        switch (_pstGPS->m_u8Mon)
        {
            gps_wait_count = 0;
            gps_need_data_flag = 1;
            gps_timeout_flag = 0;
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
                if (_pstGPS->m_u8Day > 31)
                {
                    _pstGPS->m_u8Day = 1;
                    _pstGPS->m_u8Mon++;
                }
                break;
            case 2:
                if (0 == (_pstGPS->m_u16Year % 4))
                {
                    if (_pstGPS->m_u8Day > 29)
                    {
                        _pstGPS->m_u8Day = 1;
                        _pstGPS->m_u8Mon++;
                    }
                }
                else
                {
                    if (_pstGPS->m_u8Day > 28)
                    {
                        _pstGPS->m_u8Day = 1;
                        _pstGPS->m_u8Mon++;
                    }
                }
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                if (_pstGPS->m_u8Day > 30)
                {
                    _pstGPS->m_u8Day = 1;
                    _pstGPS->m_u8Mon++;
                }
                break;
            case 12:
                if (_pstGPS->m_u8Day > 31)
                {
                    _pstGPS->m_u8Day = 1;
                    _pstGPS->m_u8Mon = 1;
                    _pstGPS->m_u16Year++;
                }
                break;
        }
    if(flag_4g_uwb)
    {
        gps_4g_flag = open_close;
    } else {
        gps_uwb_flag = open_close;
    }

}
void Gps_change(void)
{
   if(gps_open_flag){
      if(gps_need_data_flag) {
                     gps_power_state = 1;  //打开GPS电源
						 
                     gps_wait_count++;
                     if(gps_wait_count>=g_com_map[SEND_4G_SECOND]) { //超时切换工作状态
                           gps_timeout_flag=1;//串口添加改变timeout逻辑
                           gps_wait_count=0;
                           gps_need_data_flag=0;//切换为关闭模式
                           UDPClient_UploadGPS();//上传GPS超时无效数据
                     }
               } else {
                     gps_wait_count++;
                     gps_power_state=0;//关闭GPS
						 
                     if(gps_wait_count>g_com_map[SEND_4G_SECOND]) {
                           gps_power_state=1;//开启GPS
                           gps_need_data_flag=1;
                           gps_wait_count=0;
                     }
               }
               gps_wait_count2=0;
      }else{
               gps_wait_count2++;
               if(gps_wait_count2>=g_com_map[SEND_4G_SECOND]) { //超时切换工作状态
                           gps_wait_count=0;
                           gps_timeout_flag=1;
                           UDPClient_UploadGPS();//上传GPS 30s固定数据
                           gps_wait_count2=0;
                     }
            gps_power_state=1;//开启gps
        gps_need_data_flag=1;
         }
      update_led_power_state();
}

HIDO_INT32 GPS_ParseGSV(HIDO_CHAR *_pcData, HIDO_UINT32 _u32Len)
/*******************************************************************************
 * Function Name     : GPS_ParseDate
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : wx:duj_an
 * Modified Date:    : 2021年1月8日
 *******************************************************************************/
static HIDO_INT32 GPS_ParseDate(HIDO_DataStruct *_pstDateData, ST_GPS *_pstGPS)
{
    HIDO_DataStruct spower[4];
    HIDO_UINT32 u32Len = _pstDateData->m_u32Len;
    HIDO_CHAR *pcStart = (HIDO_CHAR *)_pstDateData->m_pData;

//    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)
    if (u32Len != 6)
    {
        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);

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

    _pstGPS->m_u8Day = HIDO_UtilStrBufToInt(pcStart, 2);
    _pstGPS->m_u8Mon = HIDO_UtilStrBufToInt(pcStart + 2, 2);
    _pstGPS->m_u16Year = HIDO_UtilStrBufToInt(pcStart + 4, 2) + 2000;

    return HIDO_OK;
}
}

/*******************************************************************************
 * Function Name     : GPS_ParseState
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : wx:duj_an
 * Modified Date:    : 2021年1月8日
 *******************************************************************************/
static HIDO_INT32 GPS_ParseState(HIDO_DataStruct *_pstStateData, ST_GPS *_pstGPS)
{
    HIDO_UINT32 u32Len = _pstStateData->m_u32Len;
    HIDO_CHAR *pcStart = (HIDO_CHAR *) _pstStateData->m_pData;

    if (u32Len != 1)
    {
        return HIDO_ERR;
    }

    if(pcStart[0] == 'A')
    {
        _pstGPS->m_eState = GPS_STATE_VALID;
    }
    else
    {
        _pstGPS->m_eState = GPS_STATE_INVALID;
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : GPS_ParseTime
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : wx:duj_an
 *******************************************************************************/
static HIDO_INT32 GPS_ParseTime(HIDO_DataStruct *_pstTimeData, ST_GPS *_pstGPS)
{
    HIDO_UINT32 u32Len = _pstTimeData->m_u32Len;
    HIDO_CHAR *pcStart = (HIDO_CHAR *) _pstTimeData->m_pData;
    HIDO_CHAR *pcDot = NULL;

    pcDot = HIDO_UtilStrnchr(pcStart, '.', u32Len);
    if (NULL == pcDot)
    {
        return HIDO_ERR;
    }

    if ((pcDot - pcStart) != 6)
    {
        return HIDO_ERR;
    }

    _pstGPS->m_u8Hour = HIDO_UtilStrBufToInt(pcStart, 2);
    _pstGPS->m_u8Min = HIDO_UtilStrBufToInt(pcStart + 2, 2);
    _pstGPS->m_u8Sec = HIDO_UtilStrBufToInt(pcStart + 4, 2);

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : GPS_ParseLat
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : wx:duj_an
 *******************************************************************************/
static HIDO_INT32 GPS_ParseLat(HIDO_DataStruct *_pstLatData, ST_GPS *_pstGPS)
{
    HIDO_UINT32 u32Len = _pstLatData->m_u32Len;
    HIDO_CHAR *pcStart = (HIDO_CHAR *) _pstLatData->m_pData;
    HIDO_CHAR *pcDot = NULL;
    HIDO_UINT32 u32TempLen = 0;
    double dd;
    double mmmm;
    double mm;

    if (u32Len < 9)
    {
        return HIDO_ERR;
    }

    pcDot = HIDO_UtilStrnchr(pcStart, '.', u32Len);
    if (NULL == pcDot || (pcDot - pcStart) != 4)
    {
        return HIDO_ERR;
    }

    dd = HIDO_UtilStrBufToInt(pcStart, 2);
    mm = HIDO_UtilStrBufToInt(pcStart + 2, 2);
    u32TempLen = u32Len - (pcDot + 1 - pcStart);
    mmmm = HIDO_UtilStrBufToInt(pcDot + 1, u32TempLen);
    while(u32TempLen != 0)
    {
        mmmm /= 10.0;
        u32TempLen--;
    }

    mm = mm + mmmm;
    _pstGPS->m_dLat = dd + (mm / 60.0);

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : GPS_ParseLon
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : wx:duj_an
 *******************************************************************************/
static HIDO_INT32 GPS_ParseLon(HIDO_DataStruct *_pstLonData, ST_GPS *_pstGPS)
{
    HIDO_UINT32 u32Len = _pstLonData->m_u32Len;
    HIDO_CHAR *pcStart = (HIDO_CHAR *) _pstLonData->m_pData;
    HIDO_CHAR *pcDot = NULL;
    HIDO_UINT32 u32TempLen = 0;
    double ddd;
    double mmmm;
    double mm;

    if (u32Len < 10)
    {
        return HIDO_ERR;
    }

    pcDot = HIDO_UtilStrnchr(pcStart, '.', u32Len);
    if (NULL == pcDot || (pcDot - pcStart) != 5)
    {
        return HIDO_ERR;
    }

    ddd = HIDO_UtilStrBufToInt(pcStart, 3);
    mm = HIDO_UtilStrBufToInt(pcStart + 3, 2);
    u32TempLen = u32Len - (pcDot + 1 - pcStart);
    mmmm = HIDO_UtilStrBufToInt(pcDot + 1, u32TempLen);
    while(u32TempLen != 0)
    {
        mmmm /= 10.0;
        u32TempLen--;
    }

    mm = mm + mmmm;
    _pstGPS->m_dLon = ddd + (mm / 60.0);

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : GPS_ParseDir
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : wx:duj_an
 *******************************************************************************/
static HIDO_INT32 GPS_ParseDir(HIDO_DataStruct *_pstDirData, ST_GPS *_pstGPS)
{
    HIDO_UINT32 u32Len = _pstDirData->m_u32Len;
    HIDO_CHAR *pcStart = (HIDO_CHAR *) _pstDirData->m_pData;
    HIDO_CHAR *pcDot = NULL;

    if (u32Len >= 1)
    {
        pcDot = HIDO_UtilStrnchr(pcStart, '.', u32Len);
        if (pcDot)
        {
            _pstGPS->m_u16Dir = HIDO_UtilStrBufToInt(pcStart, pcDot - pcStart);
        }
        else
        {
            _pstGPS->m_u16Dir = HIDO_UtilStrBufToInt(pcStart, u32Len);
        }
    }
    else
    {
        _pstGPS->m_u16Dir = 0;
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : GPS_ParseLatSign
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : wx:duj_an
 *******************************************************************************/
static HIDO_INT32 GPS_ParseLatSign(HIDO_DataStruct *_pstLatSignData, ST_GPS *_pstGPS)
{
    HIDO_UINT32 u32Len = _pstLatSignData->m_u32Len;
    HIDO_CHAR *pcStart = (HIDO_CHAR *) _pstLatSignData->m_pData;

    if (u32Len > 1)
    {
        return HIDO_ERR;
    }

    if (0 == u32Len)
    {
        return HIDO_OK;
    }
    else
    {
        if (pcStart[0] == 'S')
        {
            _pstGPS->m_dLat = -_pstGPS->m_dLat;
        }
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : GPS_ParseLonSign
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : wx:duj_an
 *******************************************************************************/
static HIDO_INT32 GPS_ParseLonSign(HIDO_DataStruct *_pstLonSignData, ST_GPS *_pstGPS)
{
    HIDO_UINT32 u32Len = _pstLonSignData->m_u32Len;
    HIDO_CHAR *pcStart = (HIDO_CHAR *) _pstLonSignData->m_pData;

    if (u32Len > 1)
    {
        return HIDO_ERR;
    }

    if (0 == u32Len)
    {
        return HIDO_OK;
    }
    else
    {
        if (pcStart[0] == 'W')
        {
            _pstGPS->m_dLon = -_pstGPS->m_dLon;
        }
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : GPS_ParseSpeed
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : wx:duj_an
 *******************************************************************************/
static HIDO_INT32 GPS_ParseSpeed(HIDO_DataStruct *_pstSpeedData, ST_GPS *_pstGPS)
{
    HIDO_UINT32 u32Len = _pstSpeedData->m_u32Len;
    HIDO_CHAR *pcStart = (HIDO_CHAR *) _pstSpeedData->m_pData;
    HIDO_CHAR acSpeed[10];

    if (u32Len >= 10)
    {
        return HIDO_ERR;
    }

    if (u32Len >= 1)
    {
        memcpy(acSpeed, pcStart, u32Len);
        acSpeed[u32Len] = 0;
        _pstGPS->m_u16Speed = atof(acSpeed) * 1.852;
    }
    else
    {
        _pstGPS->m_u16Speed = 0;
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : GPS_DataCheck
 * Description       : GPS数据格式检查
 * Input             : _pcData GPS数据
 *                   : _u32Len GPS数据长度
 * Output            : None
 * Return            : HIDO_OK 成功, HIDO_ERR 失败
 * Author            : hido.ltd
 * 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            : hido.ltd
 * Modified Date:    : 2021年5月07日
 *******************************************************************************/
uint8_t GPS_data[100];
uint8_t GPS_successful_flag;
extern uint32_t uwbled,rtkled,led4g,powerled;
uint8_t jinru_parsegga_flag;
uint8_t fangchai_flag;
uint8_t GPS_ParseGGA_data[256];
uint8_t GPS_ParseGGA_changdu;
extern uint16_t g_com_map[256];
extern uint8_t bat_percent;
uint8_t gpsbaoxu;
static HIDO_INT32 GPS_ParseGGA(HIDO_CHAR *_pcData, HIDO_UINT32 _u32Len)
{
    uint16_t state_flag;
    ST_GPS stGPS;
    HIDO_DataStruct stPosState;
    jinru_parsegga_flag=1;
    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_CHAR *)stPosState.m_pData != '0')
    {
//        HIDO_DebugString(_pcData, _u32Len);
        if(l_fnGPSEventCallback != NULL)
        {
            l_fnGPSEventCallback(GPS_TYPE_GGA, _pcData, _u32Len);
        }
        rtkled=BLUE;
        GPS_successful_flag=1;
        _pcData[_u32Len-1]=0;
        _pcData[_u32Len-2]=0;
//        memcpy(GPS_data,_pcData, _u32Len-2);//去掉回车换行
    state_flag = 0;
    state_flag = fangchai_flag;
        
        HIDO_UINT32 u32Len = HIDO_UtilSnprintf((HIDO_CHAR *)GPS_ParseGGA_data, sizeof(GPS_ParseGGA_data), "%s,%X,%02x,%x,%d,%d,%d,%d\r\n",
                _pcData, g_com_map[2], bat_percent,0,0,0,state_flag,gpsbaoxu);
        gpsbaoxu++;
        GPS_ParseGGA_changdu=u32Len;

    }
    else
    {
        rtkled=RED;
        GPS_successful_flag=0;
        _pcData[_u32Len-1]=0;
        _pcData[_u32Len-2]=0;
//        memcpy(GPS_data,_pcData, _u32Len-2);
            state_flag = 0;
    state_flag = fangchai_flag;
        
        HIDO_UINT32 u32Len = HIDO_UtilSnprintf((HIDO_CHAR *)GPS_ParseGGA_data, sizeof(GPS_ParseGGA_data), "%s,%X,%02x,%x,%d,%d,%d,%d\r\n",
                _pcData, g_com_map[2], bat_percent,0,0,0,state_flag,gpsbaoxu);
        gpsbaoxu++;
        GPS_ParseGGA_changdu=u32Len;
    }
    UDPClient_UploadGPS();
    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : GPS_ParseRMC
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : wx:duj_an
 *******************************************************************************/
HIDO_INT32 GPS_ParseRMC(HIDO_CHAR *_pcData, HIDO_UINT32 _u32Len)
{
    HIDO_DataStruct stTimeData;
    HIDO_DataStruct stStateData;
    HIDO_DataStruct stLatData;
    HIDO_DataStruct stLatSignData;
    HIDO_DataStruct stLonData;
    HIDO_DataStruct stLonSignData;
    HIDO_DataStruct stSpeedData;
    HIDO_DataStruct stDirData;
    HIDO_DataStruct stDateData;
    ST_GPS *_pstGPS = &l_stGPS;

    if(NULL == _pstGPS)
    {
        return HIDO_ERR;
    }

    if (GPS_DataCheck(_pcData, _u32Len) != HIDO_OK)
    {
        _pstGPS->m_eState = GPS_STATE_INVALID;
        return HIDO_ERR;
    }

    if (HIDO_UtilParseFormat((HIDO_UINT8 *) _pcData, _u32Len, "$%*,%p,%p,%p,%p,%p,%p,%p,%p,%p,%*,%*,%**", &stTimeData, &stStateData,
            &stLatData, &stLatSignData, &stLonData, &stLonSignData, &stSpeedData, &stDirData, &stDateData) != 13)
    {
        return HIDO_ERR;
    }

    if (GPS_ParseState(&stStateData, _pstGPS) != HIDO_OK)
    {
        return HIDO_ERR;
    }

    if (_pstGPS->m_eState != GPS_STATE_VALID)
    {   
        return HIDO_OK;
    }

    if (GPS_ParseTime(&stTimeData, _pstGPS) != HIDO_OK)
    {
        return HIDO_ERR;
    }

    if (GPS_ParseDate(&stDateData, _pstGPS) != HIDO_OK)
    {
        return HIDO_ERR;
    }

    if (GPS_ParseLat(&stLatData, _pstGPS) != HIDO_OK)
    {
        return HIDO_ERR;
    }

    if (GPS_ParseLon(&stLonData, _pstGPS) != HIDO_OK)
    {
        return HIDO_ERR;
    }

    if (GPS_ParseSpeed(&stSpeedData, _pstGPS) != HIDO_OK)
    {
        return HIDO_ERR;
    }

    if (GPS_ParseDir(&stDirData, _pstGPS) != HIDO_OK)
    {
        return HIDO_ERR;
    }

    if (GPS_ParseLatSign(&stLatSignData, _pstGPS) != HIDO_OK)
    {
        return HIDO_ERR;
    }

    if (GPS_ParseLonSign(&stLonSignData, _pstGPS) != HIDO_OK)
    {
        return HIDO_ERR;
    }

    GPS_AddHours(_pstGPS, 8);

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : GPS_RecvFsm
 * Description       : GPS 数据接收状态机
 * Input             : _u8RecvChar 一个接收字符
 * Output            : None
 * Return            : one
 * Author            : hido.ltd
 * Modified Date:    : 2021年5月07日
 *******************************************************************************/
HIDO_VOID GPS_RecvFsm(HIDO_UINT8 _u8RecvChar)
{
    switch (l_stGPSRecv.m_eState)
    {
        case GPS_RECV_STATE_IDLE:
        {
            if ('$' == _u8RecvChar)
            {
                l_stGPSRecv.m_eState = GPS_RECV_STATE_CR;
                l_stGPSRecv.m_u32RecvLen = 0;
                l_stGPSRecv.m_acRecvBuf[l_stGPSRecv.m_u32RecvLen++] = _u8RecvChar;
            }
            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) - 2))
            {
                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:
        {
            if ('\n' == _u8RecvChar)
            {
               l_stGPSRecv.m_acRecvBuf[l_stGPSRecv.m_u32RecvLen++] = _u8RecvChar;
               l_stGPSRecv.m_acRecvBuf[l_stGPSRecv.m_u32RecvLen] = '\0';

               if(strstr(l_stGPSRecv.m_acRecvBuf, "GGA,") != HIDO_NULL)
               {
                  GPS_ParseGGA(l_stGPSRecv.m_acRecvBuf, l_stGPSRecv.m_u32RecvLen);
                    memset(l_stGPSRecv.m_acRecvBuf,0, l_stGPSRecv.m_u32RecvLen);
               }
                else if(strstr(l_stGPSRecv.m_acRecvBuf, "RMC,") != HIDO_NULL)
               {
                  GPS_ParseRMC(l_stGPSRecv.m_acRecvBuf, l_stGPSRecv.m_u32RecvLen);
               }
            }

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

/*******************************************************************************
 * Function Name     : GPS_Rest
 * Description       : GPS复位
 * Input             : None
 * Output            : None
 * Return            : None
 * Author            : hido.ltd
 * 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_Powe.\Objects\uwb_simple_example.axf: Error: L6218E: Undefined symbol gps_power_state (referred from sn74hc595.o).rOn
 * Description       : GPS上电
 * Input             : None
 * Output            : None
 * Return            : None
 * Author            : hido.ltd
 * Modified Date:    : 2021年1月8日
 *******************************************************************************/
//HIDO_VOID GPS_PowerOn(void)
//{
//    l_bIsPowerOn = HIDO_TRUE;
////    GPIO_RESET(&l_astGPSPin[GPS_PIN_EN]);
//    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_12, GPIO_PIN_SET);
//}

/*******************************************************************************
 * Function Name     : GPS_PowerOff
 * Description       : GPS掉电
 * Input             : None
 * Output            : None
 * Return            : None
 * Author            : hido.ltd
 * Modified Date:    : 2021年1月8日
 *******************************************************************************/
//HIDO_VOID GPS_PowerOff(void)
//{
//    l_bIsPowerOn = HIDO_FALSE;
////    GPIO_RESET(&l_astGPSPin[GPS_PIN_EN]);
//    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_12, GPIO_PIN_RESET);
//}

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

/*******************************************************************************
 * Function Name     : GPS_PinRegister
 * Description       : GPS模块管脚注册
 * Input             : _ePin 管脚定义
 *                   : _pstGPIOx GPIOx
 *                   : _u16GPIOPin GPIO_PIN_x
 * Output            : None
 * Return            : None
 * Author            : hido.ltd
 * 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            : hido.ltd
 *******************************************************************************/
HIDO_VOID GPS_Poll(void)
{
    HIDO_UINT8 u8RecvChar = 0;

    while (Uart_GetChar(UART_ID_GPS, &u8RecvChar) == HIDO_OK)
    {
       GPS_RecvFsm(u8RecvChar);
    }
}

/*******************************************************************************
 * Function Name     : GPS_SetEventCallback
 * Description       : GPS设置GPS事件回调
 * Input             : None
 * Output            : None
 * Return            : None
 * Author            : hido.ltd
 *******************************************************************************/
HIDO_VOID GPS_SetEventCallback(FN_GPSEventCallback _fnEventCallback)
{
    l_fnGPSEventCallback = _fnEventCallback;
}

/*******************************************************************************
 * Function Name     : GPS_IsIdle
 * Description       : GPS轮询处理
 * Input             : None
 * Output            : None
 * Return            : None
 * Author            : hido.ltd
 *******************************************************************************/
HIDO_BOOL GPS_IsIdle(void)
{
    if(l_bIsPowerOn)
    {
        return HIDO_FALSE;
    }

    return HIDO_TRUE;
}

/*******************************************************************************
 * Function Name     : GPS_Init
 * Description       : GPS模块初始化
 * Input             : None
 * Output            : None
 * Return            : None
 * Author            : hido.ltd
 *******************************************************************************/
//HIDO_VOID GPS_Init(void)
//{
//    GPS_PowerOn();
//    GPS_Rest();

//    ST_UartInit stInit;

//    stInit.m_eRxMode = UART_RX_MODE_INT;
//    stInit.m_eTxMode = UART_TX_MODE_POLL;
//    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));
//}