GPS NMEA数据解析示例

已于 2024-08-26 11:40:42 修改
阅读量129 收藏
点赞数 3
文章标签： 算法
于 2024-08-22 19:08:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42936764/article/details/141435888
版权

gps数据解析和组包发送


#include <malloc.h>
#include <memory.h>
#include <time.h>
#include <stdbool.h>
#include <stdlib.h>
#include <cstdint>

typedef unsigned char UCHAR;

typedef struct GbGpsData{
    char isvalid;
    long longtitude;
    char lonDirect;
    long latitude;
    char latDirect;
    float speed;
    float angle;
    char year;
    char month;
    char day;
    char hour;
    char min;
    char sec;
    bool isAvailable;
}S_GbGpsData,*PS_GbGpsData;

static PS_GbGpsData g_psLocData = NULL;

#define HEAD_MCU     "\x4c\x59"
#define HEAD_LEN  	2
#define COUNT_LEN 			2
#define MCU_USRDATA_MAXLEN   1000

typedef struct {
    UCHAR MCU_Head[HEAD_LEN];
    UCHAR MCU_Command;
    UCHAR MCU_CommandRsp;
    UCHAR MAJOR;
    UCHAR MINOR;
    UCHAR MCU_DataLen[COUNT_LEN];
    UCHAR MCU_User_data[MCU_USRDATA_MAXLEN];
    UCHAR MCU_CRC;

}MCU_RECV;
MCU_RECV MCU_UartRecv;

int getComma(int num,char *str)
{
    int i,j=0;
    int len = strlen(str);

    if(len > 100)
    {
        printf("getComma len = [%d] error",len);
        return 0;
    }
    for(i=0;i<len;i++)
    {
        if(str[i]==',')
        {
            j++;
        }
        if(j==num)
        {
            return i+1;
        }
    }
    printf("getComma error\n");
    return 0;
}

double get_locate(double temp)
{
    int m;
    double n;
    m=(int)temp/100;
    n=(temp-m*100)/60;
    n=n+m;
    return n;
}

double get_double_number(char * s)
{
    char buf[64];
    int i;
    double rev;
    i=getComma(1, s);
    if(i==0)
    {
        printf("get_double_number error");
        return 0;
    }
    strncpy(buf,s,i);
    buf[i]=0;
    rev=atof(buf);
    return rev;
}

//2021/3/9校验GPS数据完整性与正确性
int GetGpsBufVerification(char *Gpsbuf)
{
    int Verification,j,num = 0;
    char str[3];
    num = getComma(13,Gpsbuf);
    if(num == 0)
    {
        printf("getComma Is ERROR,num = %d\n",num);
        return 0;
    }
    memset(str,0,sizeof(str));
    for(j=0;j<2;j++)
    {
        str[j] = Gpsbuf[num+j+2];
    }
    str[j] = '\0';
    sscanf(str,"%x\n",&Verification);
    return Verification;
}

//2021/3/9校验GPS数据完整性与正确性
int CalculateGpsBufVerification(char *Gpsbuf)
{
    int result,i;
    int len = strlen(Gpsbuf);
    for(result=Gpsbuf[1],i=2;(Gpsbuf[i]!='*') && (i < len);i++)
    {
        result^=Gpsbuf[i];
    }
    return result;
}

//DFYY_TEST
int gpsMouleSaveLocationData(PS_GbGpsData pData)
{
    if(pData == NULL)
    {
        return 1;
    }
    if(pData->isvalid == 'A')
    {
        g_psLocData->isvalid = pData->isvalid;
        g_psLocData->latDirect= pData->latDirect;
        g_psLocData->lonDirect = pData->lonDirect;
        g_psLocData->latitude = pData->latitude;
        g_psLocData->longtitude = pData->longtitude;
        g_psLocData->speed = pData->speed;
        g_psLocData->angle = pData->angle;

        g_psLocData->year = pData->year;
        g_psLocData->month = pData->month;
        g_psLocData->day = pData->day;
        g_psLocData->hour = pData->hour;
        g_psLocData->min = pData->min;
        g_psLocData->sec = pData->sec;
        return 0;

    }else if(pData->isvalid == 'V')
    {
        g_psLocData->isvalid = pData->isvalid;
        return 1;
    }else{
        return 1;
    }
}

void handleNmeaData(char * pData, int size)
{
    int idx;
    int i,j;
    int timenum;
    char str [3];
    char *buf = (char*)malloc(256);
    char *pData_Bak = (char*)malloc(1024);
    char *GPRMC;
    int GPRMC_Len = 0;
    PS_GbGpsData pGpsData = NULL;
    int ret = 1;
    char cmd[256]={0};
    struct tm ptime;
    if(buf == NULL)
    {
        return;
    }
    if(pData_Bak == NULL)
    {
        return;
    }
    memset(buf,0,256);
    memset(pData_Bak,0,1024);
    pGpsData = (PS_GbGpsData)malloc(sizeof(S_GbGpsData));

    if(size < 1024)
    {
        memcpy(pData_Bak,pData,size);
    }else{
        free(buf);
        free(pData_Bak);
        free(pGpsData);
        return;
    }
    if(!pGpsData)
    {
        free(buf);
        free(pData_Bak);
        return;
    }
    for(idx = 0;idx < size;idx++)
    {
        if((pData_Bak[idx] == '\r') || (pData_Bak[idx] == '\0'))
        {
            pData_Bak[idx] = ' ';
        }
    }
    if((GPRMC = strstr(pData_Bak,"$GNRMC"))!=NULL)
    {
        GPRMC_Len = strlen(GPRMC);
        for(i=0;i<GPRMC_Len;i++)
        {
            if(GPRMC[i] == '\n')
            {
                GPRMC[i] = '\0';
                break;
            }
        }
        memcpy(buf,GPRMC,i);
        //2021/3/3测试验证GPS数据完整性,如果第13个逗号(最后一个逗号)后有数据，则数据完整
        if((getComma(13, buf) != 0) && (GetGpsBufVerification(buf) == CalculateGpsBufVerification(buf)))
        {
            if(buf[getComma(2, buf)] == 'A')   //valid value
            {
                printf("#DFYY_TEST# GPS_BUF_DATA = %s\n",buf);
                timenum = getComma(1,buf);
                for(j=0;j<2;j++)
                {
                    str[j] = buf[timenum+j];
                }
                str[j] = '\0';
                pGpsData->hour = atof(str);
                memset(str,0,3);
                for(j=0;j<2;j++)
                {
                    str[j] = buf[timenum+2+j];
                }
                str[j] = '\0';
                pGpsData->min = atof(str);
                memset(str,0,3);
                for(j=0;j<2;j++)
                {
                    str[j] = buf[timenum+4+j];
                }
                str[j] = '\0';
                pGpsData->sec = atof(str);
                pGpsData->isvalid = 'A';
                pGpsData->latitude=get_locate(get_double_number(&buf[getComma(3, buf)]))*1000000;
                pGpsData->latDirect = buf[getComma(4, buf)];
                pGpsData->longtitude=get_locate(get_double_number(&buf[getComma(5, buf)]))*1000000;
                pGpsData->lonDirect=buf[getComma(6, buf)];
                pGpsData->speed = (float)(get_double_number(&buf[getComma(7, buf)]) * 1.8);
                pGpsData->angle = (float)get_double_number(&buf[getComma(8, buf)]);
                timenum=getComma(9, buf);
                memset(str,0,3);
                for(j=0;j<2;j++)
                {
                    str[j] = buf[timenum+j];
                }
                str[j] = '\0';
                pGpsData->day=atof(str);
                memset(str,0,3);
                for(j=0;j<2;j++)
                {
                    str[j] = buf[timenum+2+j];
                }
                str[j] = '\0';
                pGpsData->month=atof(str);
                memset(str,0,3);
                for(j=0;j<2;j++)
                {
                    str[j] = buf[timenum+4+j];
                }
                str[j] = '\0';
                pGpsData->year=atof(str);
                printf("lat direct = %c,lat = %ld,lon direct = %c,log = %ld, speed = %f, angle = %f,year = %d,month = %d, data = %d,hour = %d, min = %d, sec = %d\n",
                       pGpsData->latDirect,pGpsData->latitude,pGpsData->lonDirect,pGpsData->longtitude,pGpsData->speed,pGpsData->angle,
                       pGpsData->year,pGpsData->month,pGpsData->day,pGpsData->hour,pGpsData->min,pGpsData->sec);
            }
            else{
                pGpsData->isvalid='V';
                printf("no valid value data pGpsData->isvalid=[%c]\n",pGpsData->isvalid);
            }
        }
        else
        {
            printf("this gps data is incorrect,the buf is %s,GetVerification is %d,CalculateVerification is %d\n",buf,
                   GetGpsBufVerification(buf),CalculateGpsBufVerification(buf));
        }
    }
    gpsMouleSaveLocationData(pGpsData);
    free(buf);
    free(pData_Bak);
    free(pGpsData);
}

unsigned int getTimeStamp(void)
{
    struct timespec time;
    memset(&time, 0, sizeof(struct timespec));
    clock_gettime(CLOCK_REALTIME, &time);
    return time.tv_sec;
}

unsigned char  BCC( UCHAR *upCreatBcc_Data, unsigned int uCreatBcc_Data_len)
{
    int bcc=0;
    unsigned int i;
    for (i = 2; i<uCreatBcc_Data_len; i++)
        bcc ^= upCreatBcc_Data[i];
    return bcc;
}

void printRawData( const char *head,UCHAR  const * data, int len)
{
    int i;
    char *p;
    char *buffer;
    int bufferSize = 3 * (len + 1);
    buffer = (char*)malloc(bufferSize);
    if(!buffer)
    {
        return;
    }
    p = buffer;
    memset(p, 0, bufferSize);
    for(i=0; i<len; i++)
    {
        sprintf(p, "%02X ", data[i]);
        p += 3;
    }
    printf( "RAW:%s%s\n", head,buffer);
    free(buffer);
}

int  make_GBframe(UCHAR MCU_Command, UCHAR  ack,   UCHAR * data,  unsigned  int  data_length)
{
    UCHAR *packet =NULL;
    unsigned char bcc = 0;
    unsigned char length = data_length + 10;
    unsigned  char ACK_GB=ack;
    MCU_UartRecv.MAJOR = 0X02;
    MCU_UartRecv.MINOR = 0X02;
    int  len = 0;
    // 	  char encrypt_type=0x01;
    if(data != NULL)
    {
        //    printRawData(data, data_length);
    }
    packet = ( UCHAR* )malloc(length);
    if(packet)
    {
        memset(packet, 0, length);
        memcpy(packet, HEAD_MCU, HEAD_LEN);
        memcpy(packet+2, &MCU_Command, 1);
        memcpy(packet+3, &ACK_GB, 1);
        memcpy(packet+4, &MCU_UartRecv.MAJOR, 1);
        memcpy(packet+5, &MCU_UartRecv.MINOR, 1);
        packet[6] = 0xff&(data_length>>8);
        packet[7] = 0xff&(data_length);
        if((data != NULL) && (data_length != 0))
        {
            memcpy(packet+8, data, data_length);
        }
        bcc = BCC(packet, 8+ data_length);
        memcpy(packet+8+data_length, &bcc, 1);
    }
    len = 50;
    printRawData( " ",packet, len);

//    if(((g_sUartModuleHandler.fd >= 0)&&( g_module_infor_status.Available_Status==1)) || (g_sUartModuleHandler.otaStatus))
//    {
//        len = write(g_sUartModuleHandler.fd,packet,data_length + 9);
//        if(len>=0)
//        {
//            printf(" mcu_manager  dispatch %d bytes Via UART \n",len);
//            printRawData( /*ELOG_LVL_DEBUG,TAG_NONE,*/" ",packet, len);
//        }
//        else
//            printf(" mcu_manager dispatch error Via UART \n");
//        //free(packet);
//    }
//    else
//    {
//        printf(" mcu_manager MCU unavailable\n");
//    }
    if (packet)
        free(packet);
    return len;
}

void onSendGPSTimeout(void *context)
{
    printf("it's time to send GPS data\n");
    UCHAR data_temp[31]={0};
    data_temp[0] = 0x02;
    unsigned int time_stamp = getTimeStamp();
    struct tm *p;
    p=localtime((time_t *)&(time_stamp));
    data_temp[1] = p->tm_year-100;
    data_temp[2] = p->tm_mon+1;
    data_temp[3] = p->tm_mday;
    data_temp[4] = p->tm_hour;
    data_temp[5] = p->tm_min;
    data_temp[6] = p->tm_sec;
    if(g_psLocData->isvalid == 'A')
    {
        data_temp[7] = 0x00;
    }else{
        data_temp[7] = 0x01;
    }
    data_temp[8] = 0x02;    //定位系统类型GPS
    if(g_psLocData->latDirect == 'N')
    {
        data_temp[9] = 0x00;
    }else{
        data_temp[9] = 0x01;
    }
    data_temp[10] = (UCHAR)(((uint32_t)g_psLocData->latitude)>>24);
    data_temp[11] = (UCHAR)(((uint32_t)g_psLocData->latitude)>>16);
    data_temp[12] = (UCHAR)(((uint32_t)g_psLocData->latitude)>>8);
    data_temp[13] = (UCHAR)((uint32_t)g_psLocData->latitude);
    if(g_psLocData->lonDirect == 'E')
    {
        data_temp[14] = 0x00;
    }else{
        data_temp[14] = 0x01;
    }
    data_temp[15] = (UCHAR)(((uint32_t)g_psLocData->longtitude)>>24);
    data_temp[16] = (UCHAR)(((uint32_t)g_psLocData->longtitude)>>16);
    data_temp[17] = (UCHAR)(((uint32_t)g_psLocData->longtitude)>>8);
    data_temp[18] = (UCHAR)((uint32_t)g_psLocData->longtitude);
    data_temp[19] = (UCHAR)(((uint32_t)g_psLocData->speed)>>8);   //速度
    data_temp[20] = (UCHAR)((uint32_t)g_psLocData->speed);
    data_temp[21] = 0xFF;   //海拔
    data_temp[22] = 0xFF;
    data_temp[23] = (UCHAR)(((uint32_t)g_psLocData->angle)>>8);   //方位角
    data_temp[24] = (UCHAR)((uint32_t)g_psLocData->angle);
    printf("speed is %f,angle is %f\n",g_psLocData->speed,g_psLocData->angle);
    data_temp[25] = g_psLocData->year;
    data_temp[26] = g_psLocData->month;
    data_temp[27] = g_psLocData->day;
    data_temp[28] = g_psLocData->hour+8;
    data_temp[29] = g_psLocData->min;
    data_temp[30] = g_psLocData->sec;
    int len = make_GBframe(0xC6, 0xFE, (UCHAR*)data_temp, sizeof(data_temp));
    printRawData("GPS data ",data_temp,sizeof(data_temp));
}

int main(){
    g_psLocData = (PS_GbGpsData)malloc(sizeof(S_GbGpsData));
    memset(g_psLocData, 0x00, sizeof(S_GbGpsData));
    char *buf = NULL;
    buf = (char*)malloc(4096);
    memset(buf,0,4096);
    buf = "$GNRMC,101033.00,A,2322.85223,N,11310.35019,E,0.056,,220824,,,A,V*1A\n"
          "$GNGGA,101033.00,2322.85223,N,11310.35019,E,1,06,3.86,21.6,M,-6.1,M,,*65\n"
          "$GNGSA,A,3,28,32,31,25,12,,,,,,,,4.33,3.86,1.96,";
    int len = strlen(buf);
    printf("len = %d\n",len);
    handleNmeaData(buf,len);
    onSendGPSTimeout(NULL);
    if (g_psLocData){
        free(g_psLocData);
    }
    return 0;
}

long 转成16进制


#include <cstdlib>
#include <cstring>
#include <cstdio>

typedef unsigned char UCHAR;

void printRawData( const char *head,UCHAR  const * data, int len)
{
    int i;
    char *p;
    char *buffer;
    int bufferSize = 3 * (len + 1);
    buffer = (char*)malloc(bufferSize);
    if(!buffer)
    {
        return;
    }
    p = buffer;
    memset(p, 0, bufferSize);
    for(i=0; i<len; i++)
    {
        sprintf(p, "%02X ", data[i]);
        p += 3;
    }
    printf( "RAW:%s%s\n", head,buffer);
    free(buffer);
}

int main(){
    long latitude = 23380870;
    unsigned char data_temp[4] = {0};
    data_temp[0] = (latitude>>24);
    data_temp[1] = (latitude>>16);
    data_temp[2] = (latitude>>8);
    data_temp[3] = (latitude);
    printRawData(" ",data_temp,4);
    return 0;
}
豆豆plus
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java解析nmea_Java Marine API – 寻找NMEA数据
weixin_29586571的博客
03-05 517
我的最终目标是从Adafruit Ultimate GPS(NMEA 0183标准)到我的Java应用程序接收lat和长GPS信息.我正在使用Java Marine API来执行此操作.然后将当前位置与时间戳一起写入DB.到目前为止,我已成功(我认为)配置RXTX以通过USB端口启用com. Java Marine API附带了一些示例.java文件.下面的例子应该扫描所有现有的COM端口并寻找N...
GPS数据解析 示例，源代码
02-27
在提供的源代码中，开发者已经实现了一个示例流程，从读取GPS数据到解析、拆分、坐标转换，最后到绘制线路图。这是一次很好的学习机会，可以帮助我们深入理解GPS数据处理的各个环节。在实际应用中，可能需要根据具体...
GPS(NMEA 0183)数据解析
xlbtlmy的博客
11-15 847
GPS(NMEA 0183)数据解析
C++实现GNSS/GPS的NMEA数据格式解析类示例
halazi100
05-05 4724
nmea数据具体各字段的含义请参考标准定义，这里给出一个C++实现的例子，环境是Android； 解析.h头文件 #ifndef VENDOR_HAL_GNSS_V1_0_GPSNMEAPARSER_H #define VENDOR_HAL_GNSS_V1_0_GPSNMEAPARSER_H #include <cstdio> #include <iostream>...
GPS原始信号数据解析
qingfengxd1的博客
05-06 7913
GPS 上电后，每隔一定的时间就会返回一定格式的数据，数据格式为： $信息类型，x，x，x，x，x，x，x，x，x，x，x，x，x每行开头的字符都是'$'，接着是信息类型，后面是数据，以逗号分隔开。 一行完整的数据如下： $GPRMC,080655.00,A,4546.40891,N,12639.65641,E,1.045,328.42,170809,,,A*60 GPRMC 最小定位信息...
nmea.rar_GPS信号解析_GPS数据处理_NMEA解析_数据解析_解析nmea
09-19
“NMEA解析”专门指的是理解和解析遵循NMEA 0183或NMEA 2000协议的GPS数据串行通信格式。NMEA语句通常以"$"开头，后跟特定的标识符，如"GPGGA"代表全球定位系统固定数据，包括纬度、经度、定位质量等信息。解析NMEA...
GPS串口协议解析(nmea0183)
12-15
标题 "GPS串口协议解析(nmea0183)" 涉及的是全球定位系统（GPS）如何通过串行接口使用NMEA 0183协议进行数据通信的知识点。NMEA 0183是一种广泛应用于航海、航空、车辆追踪等领域的标准化通信协议，用于在GPS接收器...
GPS.zip_GPS模块数据解析_SNN_gps单片机程序
09-23
在“推荐使用”的文件“GPS数据解析”中，可能包含了详细的解析算法、代码示例或指南，帮助开发者理解如何从NMEA字符串中提取关键信息。这可能涵盖了字符串分隔、数据类型转换、异常处理等方面的知识。 总结来说，...
趣味算法------试用 6 和 9 组成的最大数字
最新发布
markingyi的博客
08-26 263
给出一个数字，反转其中一位使数字最大化，递归求解。
代码随想录算法训练营19-回溯1
weixin_53416771的博客
08-22 385
画出来的树是这样记录所有组合，一个变量current装当前的处理结果，一个res装所有的处理的结果下面的代码还可以剪枝优化。
算法日记day 45（单调栈之每日温度|接雨水）
m0_74980681的博客
08-22 903
如果大于，则取栈顶元素为中间值并弹出栈顶元素，将遍历的元素与新的栈顶元素值比较取较小者，减去中间值得到高度h，然后栈顶元素下标值减去当前遍历的元素下标值再减一得到宽度w，最后高×宽得到面积，并记录，重复上述操作，直到遍历结束。第三种，如果遍历的元素值大于栈顶元素，用该下标减去栈顶元素下标，并将栈顶元素弹出，继续用该元素与新的栈顶元素比较，如果小于等于，则压入栈，如果大于，重复第三步操作。第一种，如果之后遍历的元素值小于栈顶压入的元素，将该元素的下标压入栈中。如果小于栈顶元素值，则压入栈内。
7-7 数组中能被5整除的数的和
Virgo_616的博客
08-26 154
在一维数组中有10个整数，求出其中能被5整除的所有数的和。
算法025：前缀和
m0_62319039的博客
08-22 252
算法025：前缀和
C++ | Leetcode C++题解之第374题猜数字大小
Ddddddd_158的博客
08-26 304
C++ | Leetcode C++题解之第374题猜数字大小
算法笔试-编程练习-01-B-23
志远的博客
08-23 863
小红组内有 n 个人，大家合作完成了一个初版方案，初始时大家的愤怒值都是 0。 但是领导对方案并不满意，共需要修改 m 次方案，每次修改会先让第 l 到 r 个人的愤怒值加 1，然后再修改方案；
代码随想录算法训练营第二十二天| 回溯算法理论基础 77. 组合 216.组合总和III 17.电话号码的字母组合
Mwicogito的博客
08-23 1123
回溯法章节开始，逐渐开始正式复习算法设计课的知识。文章图片来源：代码随想录 (https://programmercarl.com/)
超分之最近邻插值、线性插值、双线性插值、双三次插值原理
weixin_44342777的博客
08-25 625
超分用于对照实验，或生成低分辨率数据集的常用插值方式：最近邻插值、线性插值、双线性插值、双三次插值的实现原理
代码随想录day46 647. 回文子串 516.最长回文子序列
weixin_45461296的博客
08-22 389
【代码】代码随想录day46 647. 回文子串 516.最长回文子序列。
基于NMEA协议的GPS数据解析与信息提取
文档中提到的四个示例数据段分别代表了不同类型的GPS输出： 1. $GPGGA: 这是全球定位系统差分定位服务(GPS-DGPS)全球数据块，包含了UTC时间（02时56分20秒）、纬度（北纬26度02.33721分，用ddmm.mmmm格式表示）、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值