GPS(NMEA 0183)数据解析

已于 2022-11-15 18:16:41 修改
阅读量834 收藏 1
点赞数
分类专栏： c语言 文章标签： c++ 算法 c语言
于 2022-11-15 00:17:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011958166/article/details/127858302
版权 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define _STR(x)    #x
#define STR(x)    _STR(x)

#define ARRAY_SIZE(array)	(sizeof(array)/sizeof(array[0]))

#define NMEA_UNIT_LEN 20
#define NMEA_INFO_LEN 16

#if 0
"$GPRMC,173843,A,3349.896,N,11808.521,W,000.0,360.0,230108,013.4,E*69\r\n",
"$GPGGA,111609.14,5001.27,N,3613.06,E,3,08,0.0,10.2,M,0.0,M,0.0,0000*70\r\n",
"$GPGSV,2,1,08,01,05,005,80,02,05,050,80,03,05,095,80,04,05,140,80*7f\r\n",
"$GPGSV,2,2,08,05,05,185,80,06,05,230,80,07,05,275,80,08,05,320,80*71\r\n",
"$GPGSA,A,3,01,02,03,04,05,06,07,08,00,00,00,00,0.0,0.0,0.0*3a\r\n",
"$GPRMC,111609.14,A,5001.27,N,3613.06,E,11.2,0.0,261206,0.0,E*50\r\n",
"$GPVTG,217.5,T,208.8,M,000.00,N,000.01,K*4C\r\n"
#endif

char nmea_info[NMEA_UNIT_LEN][NMEA_INFO_LEN] = {0};

void nmea_init(char *info);
void nmea_parse(char *str, char *info);
void nmea_decode(char *info);
void showInfo(char *info);

int main(int argc, char *argv[])
{
	char *gps_str[]= {
		"$GPGGA,111609.14,5001.27,N,3613.06,E,3,08,0.0,10.2,M,0.0,M,0.0,0000*70\r\n",
        "$GPGSA,A,3,01,02,03,04,05,06,07,08,00,00,00,00,0.0,0.0,0.0*3a\r\n",
        "$GPGSV,2,1,08,01,05,005,80,02,05,050,80,03,05,095,80,04,05,140,80*7f\r\n",
        "$GPRMC,111609.14,A,5001.27,N,3613.06,E,11.2,0.0,261206,0.0,E*50\r\n",
        "$GPVTG,217.5,T,208.8,M,000.00,N,000.01,K*4C\r\n",
        "$GPGLL,4250.5589,S,14718.5084,E,092204.999,A*2D\r\n",
	};
	
	for (int i = 0; i < 6; i ++)
	{
		nmea_init((char *)nmea_info);
		
		nmea_parse(gps_str[i], (char *)nmea_info);
	#if 0
		showInfo((char *)nmea_info);
	#endif
		nmea_decode((char *)nmea_info);
	}

	return 0;
}

void nmea_init(char *info)
{
	for (int i = 0; i < NMEA_UNIT_LEN; i ++)
	{
		for (int j = 0; j < NMEA_INFO_LEN; j ++)
		{
			info[i * NMEA_INFO_LEN + j] = '\0';
		}
	}
}

void nmea_parse(char *str, char *info)
{
	if (NULL == str || NULL == info)
	{
		printf("pointer is NULL!\n");

		return;
	}

	if ('$' != str[0])
	{
		printf("format is error!\n");

		return;
	}

	int i, j, k;

	i = 0;
	j = 0;
	k = 1;

	while (1)
	{
		if (('*' == str[k]) || ('\r' == str[k] && '\n' == str[k + 1]))
		{
			break;
		}

		if (',' == str[k])
		{
			i ++;
			j = 0;
		}
		else
		{
			info[i * NMEA_INFO_LEN + j] = str[k];

			j ++;
		}
		
		k ++;
	}
}

enum
{
	ID_N,	// none
	ID_C,	// char
	ID_D,	// double
	ID_I,	// int
};

#define MAX_ID_LEN      6
#define MAX_FLAG_LEN    19

struct NMEA2GNSS
{
    void (*parse)(char *info);
    unsigned char len;
	char id[MAX_ID_LEN];    // GPGGA/GPGSA/......
	char flag[MAX_FLAG_LEN];// <01>,<02>,...,<19>
};

void gpgga_parse(char *info);
void gpgsa_parse(char *info);
void gpgsv_parse(char *info);
void gprmc_parse(char *info);
void gpvtg_parse(char *info);
void gpgll_parse(char *info);

struct NMEA2GNSS nmea_tbl[] = {
	/*      parse,len,    <00>, <01>, <02>, <03>, <04>, <05>, <06>, <07>, <08>, <09>, <10>, <11>, <12>, <13>, <14>, <15>, <16>, <17>, <18>, <19> */
	{ gpgga_parse, 14, "GPGGA", ID_D, ID_D, ID_C, ID_D, ID_C, ID_I, ID_I, ID_D, ID_D, ID_C, ID_D, ID_C, ID_D, ID_I, ID_N, ID_N, ID_N, ID_N, ID_N },
	{ gpgsa_parse, 17, "GPGSA", ID_C, ID_I, ID_I, ID_I, ID_I, ID_I, ID_I, ID_I, ID_I, ID_I, ID_I, ID_I, ID_I, ID_I, ID_D, ID_D, ID_D, ID_N, ID_N },
	{ gpgsv_parse, 19, "GPGSV", ID_I, ID_I, ID_I, ID_I, ID_D, ID_D, ID_I, ID_I, ID_D, ID_D, ID_I, ID_I, ID_D, ID_D, ID_I, ID_I, ID_D, ID_D, ID_I },
	{ gprmc_parse, 11, "GPRMC", ID_D, ID_C, ID_D, ID_C, ID_D, ID_C, ID_D, ID_D, ID_D, ID_D, ID_C, ID_N, ID_N, ID_N, ID_N, ID_N, ID_N, ID_N, ID_N },
	{ gpvtg_parse,  8, "GPVTG", ID_D, ID_C, ID_D, ID_C, ID_D, ID_C, ID_D, ID_C, ID_N, ID_N, ID_N, ID_N, ID_N, ID_N, ID_N, ID_N, ID_N, ID_N, ID_N },
	{ gpgll_parse,  6, "GPGLL", ID_D, ID_C, ID_D, ID_C, ID_D, ID_C, ID_N, ID_N, ID_N, ID_N, ID_N, ID_N, ID_N, ID_N, ID_N, ID_N, ID_N, ID_N, ID_N },
};

void nmea_decode(char *info)
{
	if (NULL == info)
	{
		printf("pointer is NULL!\n");

		return;
	}
	
	for (int i = 0; i < ARRAY_SIZE(nmea_tbl); i ++)
	{
		if (0 == strcmp(nmea_tbl[i].id, &info[0]))
		{
        #if 1
            nmea_tbl[i].parse(&info[0]);
        #else
			printf("%s:", nmea_tbl[i].id);
			
			for (int j = 1; j <= nmea_tbl[i].len; j ++)
			{
				char *p = &info[j * NMEA_INFO_LEN];

				if (strlen(p))
				{
					switch (nmea_tbl[i].flag[j-1])
					{
					case ID_N:
						break;
					case ID_C:	// char
                        printf("%c", p[0]);
						break;
					case ID_D:	// double
                    {
                        double d = atof(p);
                        printf("%f", d);
						break;
                    }
					case ID_I:	// int
                    {
                        int val = atoi(p);
                        printf("%d", val);
						break;
                    }
					default:
						break;
					}

                    printf("|");
				}
                else
                {
                    printf(" ");
                }
			}

            printf("\n");
			
			break;
        #endif
		}
	}
}

void showInfo(char *info)
{
	printf("%s:Enter-------------\n", __FUNCTION__);
	
	for (int i = 0; i < NMEA_UNIT_LEN; i ++)
	{
		char *p = &info[i * NMEA_INFO_LEN];
		
		if (strlen(p))
		{
			printf("%s\n", p);
		}
	}

	printf("%s:Exit -------------\n", __FUNCTION__);
}

typedef unsigned int uint32_t;

enum
{
    INVALID = 0x00,
    VALID
};

struct gpgga
{
	uint32_t valid_utc;
	double utc;
	uint32_t valid_latitude;
	double latitude;
	uint32_t valid_longitude;
	double longitude;
	uint32_t valid_fix_quality;
	uint32_t fix_quality;
	uint32_t valid_number_of_satellites;
	uint32_t number_of_satellites;
	uint32_t valid_hdop;
	double hdop;
	uint32_t valid_altitude;
	double altitude;
	uint32_t valid_height_of_geoid;
	double height_of_geoid;
	uint32_t valid_time_since_dgps_update;
	double time_since_dgps_update;
	uint32_t valid_dgps_station_id;
	uint32_t dgps_station_id;
};

struct gpgga gpgga_data;

void gpgga_parse(char *info)
{
    printf("%s\n", __FUNCTION__);

    memset(&gpgga_data, sizeof(gpgga_data), 0);

    char *p1, *p2;
    
    // GNSS_GPGGA_UTC
    p1 = &info[1 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgga_data.valid_utc = VALID;
        gpgga_data.utc = atof(p1);

        printf("%s:%f\n", STR(gpgga_data.utc), gpgga_data.utc);
    }
    else
    {
        gpgga_data.valid_utc = INVALID;
    }

    // GNSS_GPGGA_LATITUDE
    p1 = &info[2 * NMEA_INFO_LEN];
    p2 = &info[3 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgga_data.valid_latitude = VALID;
        gpgga_data.latitude = atof(p1);

        char c = p2[0];

        if ('N' == c)
        {
            gpgga_data.latitude = gpgga_data.latitude;
        }
        else if ('S' == c)
        {
            gpgga_data.latitude =-gpgga_data.latitude;
        }
        else
        {
            // do_nothing();
        }

        printf("%s:%f\n", STR(gpgga_data.latitude), gpgga_data.latitude);
    }
    else
    {
        gpgga_data.valid_latitude = INVALID;
    }

    // GNSS_GPGGA_LONGITUDE
    p1 = &info[4 * NMEA_INFO_LEN];
    p2 = &info[5 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgga_data.valid_longitude = VALID;
        gpgga_data.longitude = atof(p1);

        char c = p2[0];

        if ('N' == c)
        {
            gpgga_data.longitude = gpgga_data.longitude;
        }
        else if ('S' == c)
        {
            gpgga_data.longitude =-gpgga_data.longitude;
        }
        else
        {
            // do_nothing();
        }

        printf("%s:%f\n", STR(gpgga_data.longitude), gpgga_data.longitude);
    }
    else
    {
        gpgga_data.valid_longitude = INVALID;
    }

    // GNSS_GPGGA_FIX_QUALITY
    p1 = &info[6 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgga_data.valid_fix_quality = VALID;
        gpgga_data.fix_quality = atoi(p1);

        printf("%s:%d\n", STR(gpgga_data.fix_quality), gpgga_data.fix_quality);
    }
    else
    {
        gpgga_data.valid_fix_quality = INVALID;
    }

    // GNSS_GPGGA_NUMBER_OF_SATELLITES
    p1 = &info[7 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgga_data.valid_number_of_satellites = VALID;
        gpgga_data.number_of_satellites = atoi(p1);

        printf("%s:%d\n", STR(gpgga_data.number_of_satellites), gpgga_data.number_of_satellites);
    }
    else
    {
        gpgga_data.valid_number_of_satellites = INVALID;
    }

    // GNSS_GPGGA_HDOP
    p1 = &info[8 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgga_data.valid_hdop = VALID;
        gpgga_data.hdop = atof(p1);

        printf("%s:%f\n", STR(gpgga_data.hdop), gpgga_data.hdop);
    }
    else
    {
        gpgga_data.valid_hdop = INVALID;
    }

    // GNSS_GPGGA_ALTITUDE
    p1 = &info[9 * NMEA_INFO_LEN];
    p2 = &info[10* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgga_data.valid_altitude = VALID;
        gpgga_data.altitude = atof(p1);

        char c = p2[0];

        if ('M' == c)
        {
            // do_nothing();
        }

        printf("%s:%f\n", STR(gpgga_data.altitude), gpgga_data.altitude);
    }
    else
    {
        gpgga_data.valid_altitude = INVALID;
    }

    // GNSS_GPGGA_HEIGHT_OF_GEOID
    p1 = &info[11* NMEA_INFO_LEN];
    p2 = &info[12* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgga_data.valid_height_of_geoid = VALID;
        gpgga_data.height_of_geoid = atof(p1);

        char c = p2[0];

        if ('M' == c)
        {
            // do_nothing();
        }

        printf("%s:%f\n", STR(gpgga_data.height_of_geoid), gpgga_data.height_of_geoid);
    }
    else
    {
        gpgga_data.valid_height_of_geoid = INVALID;
    }

    // GNSS_GPGGA_TIME_SINCE_DGPS_UPDATE
    p1 = &info[13* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgga_data.valid_time_since_dgps_update = VALID;
        gpgga_data.time_since_dgps_update = atof(p1);

        printf("%s:%f\n", STR(gpgga_data.time_since_dgps_update), gpgga_data.time_since_dgps_update);
    }
    else
    {
        gpgga_data.valid_time_since_dgps_update = INVALID;
    }

    // GNSS_GPGGA_DGPS_STATION_ID
    p1 = &info[13* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgga_data.valid_dgps_station_id = VALID;
        gpgga_data.dgps_station_id = atoi(p1);

        printf("%s:%d\n", STR(gpgga_data.dgps_station_id), gpgga_data.dgps_station_id);
    }
    else
    {
        gpgga_data.valid_dgps_station_id = INVALID;
    }
}

struct gpgsa
{
    uint32_t valid_mode;
    uint32_t mode;
    uint32_t valid_type;
    uint32_t type;
    uint32_t valid_prn_1;
    uint32_t prn_1;
    uint32_t valid_prn_2;
    uint32_t prn_2;
    uint32_t valid_prn_3;
    uint32_t prn_3;
    uint32_t valid_prn_4;
    uint32_t prn_4;
    uint32_t valid_prn_5;
    uint32_t prn_5;
    uint32_t valid_prn_6;
    uint32_t prn_6;
    uint32_t valid_prn_7;
    uint32_t prn_7;
    uint32_t valid_prn_8;
    uint32_t prn_8;
    uint32_t valid_prn_9;
    uint32_t prn_9;
    uint32_t valid_prn_10;
    uint32_t prn_10;
    uint32_t valid_prn_11;
    uint32_t prn_11;
    uint32_t valid_prn_12;
    uint32_t prn_12;
    uint32_t valid_pdop;
    double pdop;
    uint32_t valid_hdop;
    double hdop;
    uint32_t valid_vdop;
    double vdop;
};

struct gpgsa gpgsa_data;

void gpgsa_parse(char *info)
{
    printf("%s\n", __FUNCTION__);

    memset(&gpgsa_data, sizeof(gpgsa_data), 0);

    char *p1, *p2;

    // GNSS_GPGSA_MODE
    p1 = &info[1 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsa_data.valid_mode = VALID;
        gpgsa_data.mode = p1[0];

        printf("%s:%c\n", STR(gpgsa_data.mode), gpgsa_data.mode);
    }
    else
    {
        gpgsa_data.valid_mode = INVALID;
    }

    // GNSS_GPGSA_TYPE
    p1 = &info[2 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsa_data.valid_type = VALID;
        gpgsa_data.type = atoi(p1);

        printf("%s:%d\n", STR(gpgsa_data.type), gpgsa_data.type);
    }
    else
    {
        gpgsa_data.valid_type = INVALID;
    }

    // GNSS_GPGSA_PRN_1
    p1 = &info[3 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsa_data.valid_prn_1 = VALID;
        gpgsa_data.prn_1 = atoi(p1);

        printf("%s:%d\n", STR(gpgsa_data.prn_1), gpgsa_data.prn_1);
    }
    else
    {
        gpgsa_data.valid_prn_1 = INVALID;
    }

    // GNSS_GPGSA_PRN_2
    p1 = &info[4 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsa_data.valid_prn_2 = VALID;
        gpgsa_data.prn_2 = atoi(p1);

        printf("%s:%d\n", STR(gpgsa_data.prn_2), gpgsa_data.prn_2);
    }
    else
    {
        gpgsa_data.valid_prn_2 = INVALID;
    }

    // GNSS_GPGSA_PRN_3
    p1 = &info[5 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsa_data.valid_prn_3 = VALID;
        gpgsa_data.prn_3 = atoi(p1);

        printf("%s:%d\n", STR(gpgsa_data.prn_3), gpgsa_data.prn_3);
    }
    else
    {
        gpgsa_data.valid_prn_3 = INVALID;
    }

    // GNSS_GPGSA_PRN_4
    p1 = &info[6 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsa_data.valid_prn_4 = VALID;
        gpgsa_data.prn_4 = atoi(p1);

        printf("%s:%d\n", STR(gpgsa_data.prn_4), gpgsa_data.prn_4);
    }
    else
    {
        gpgsa_data.valid_prn_4 = INVALID;
    }

    // GNSS_GPGSA_PRN_5
    p1 = &info[7 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsa_data.valid_prn_5 = VALID;
        gpgsa_data.prn_5 = atoi(p1);

        printf("%s:%d\n", STR(gpgsa_data.prn_5), gpgsa_data.prn_5);
    }
    else
    {
        gpgsa_data.valid_prn_5 = INVALID;
    }

    // GNSS_GPGSA_PRN_6
    p1 = &info[8 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsa_data.valid_prn_6 = VALID;
        gpgsa_data.prn_6 = atoi(p1);

        printf("%s:%d\n", STR(gpgsa_data.prn_6), gpgsa_data.prn_6);
    }
    else
    {
        gpgsa_data.valid_prn_6 = INVALID;
    }

    // GNSS_GPGSA_PRN_7
    p1 = &info[9 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsa_data.valid_prn_7 = VALID;
        gpgsa_data.prn_7 = atoi(p1);

        printf("%s:%d\n", STR(gpgsa_data.prn_7), gpgsa_data.prn_7);
    }
    else
    {
        gpgsa_data.valid_prn_7 = INVALID;
    }

    // GNSS_GPGSA_PRN_8
    p1 = &info[10* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsa_data.valid_prn_8 = VALID;
        gpgsa_data.prn_8 = atoi(p1);

        printf("%s:%d\n", STR(gpgsa_data.prn_8), gpgsa_data.prn_8);
    }
    else
    {
        gpgsa_data.valid_prn_8 = INVALID;
    }

    // GNSS_GPGSA_PRN_9
    p1 = &info[11* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsa_data.valid_prn_9 = VALID;
        gpgsa_data.prn_9 = atoi(p1);

        printf("%s:%d\n", STR(gpgsa_data.prn_9), gpgsa_data.prn_9);
    }
    else
    {
        gpgsa_data.valid_prn_9 = INVALID;
    }

    // GNSS_GPGSA_PRN_10
    p1 = &info[12* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsa_data.valid_prn_10= VALID;
        gpgsa_data.prn_10= atoi(p1);

        printf("%s:%d\n", STR(gpgsa_data.prn_10), gpgsa_data.prn_10);
    }
    else
    {
        gpgsa_data.valid_prn_10= INVALID;
    }

    // GNSS_GPGSA_PRN_11
    p1 = &info[13* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsa_data.valid_prn_11= VALID;
        gpgsa_data.prn_11= atoi(p1);

        printf("%s:%d\n", STR(gpgsa_data.prn_11), gpgsa_data.prn_11);
    }
    else
    {
        gpgsa_data.valid_prn_11= INVALID;
    }

    // GNSS_GPGSA_PRN_12
    p1 = &info[14* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsa_data.valid_prn_12= VALID;
        gpgsa_data.prn_12= atoi(p1);

        printf("%s:%d\n", STR(gpgsa_data.prn_12), gpgsa_data.prn_12);
    }
    else
    {
        gpgsa_data.valid_prn_12= INVALID;
    }

    // GNSS_GPGSA_PDOP
    p1 = &info[15* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsa_data.valid_pdop= VALID;
        gpgsa_data.pdop = atof(p1);

        printf("%s:%f\n", STR(gpgsa_data.pdop), gpgsa_data.pdop);
    }
    else
    {
        gpgsa_data.valid_pdop = INVALID;
    }

    // GNSS_GPGSA_HDOP
    p1 = &info[16* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsa_data.valid_hdop= VALID;
        gpgsa_data.hdop = atof(p1);

        printf("%s:%f\n", STR(gpgsa_data.hdop), gpgsa_data.hdop);
    }
    else
    {
        gpgsa_data.valid_hdop = INVALID;
    }

    // GNSS_GPGSA_VDOP
    p1 = &info[17* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsa_data.valid_vdop= VALID;
        gpgsa_data.vdop = atof(p1);

        printf("%s:%f\n", STR(gpgsa_data.vdop), gpgsa_data.vdop);
    }
    else
    {
        gpgsa_data.valid_vdop = INVALID;
    }
}

struct gpgsv
{
    uint32_t valid_number_of_messages;
    uint32_t number_of_messages;
    uint32_t valid_message_number;
    uint32_t message_number;
    uint32_t valid_total_number_of_svs;
    uint32_t total_number_of_svs;

    uint32_t valid_sv1_prn;
    uint32_t sv1_prn;
    uint32_t valid_sv1_elevation;
    double sv1_elevation;
    uint32_t valid_sv1_azimuth;
    double sv1_azimuth;
    uint32_t valid_sv1_snr;
    uint32_t sv1_snr;

    uint32_t valid_sv2_prn;
    uint32_t sv2_prn;
    uint32_t valid_sv2_elevation;
    double sv2_elevation;
    uint32_t valid_sv2_azimuth;
    double sv2_azimuth;
    uint32_t valid_sv2_snr;
    uint32_t sv2_snr;

    uint32_t valid_sv3_prn;
    uint32_t sv3_prn;
    uint32_t valid_sv3_elevation;
    double sv3_elevation;
    uint32_t valid_sv3_azimuth;
    double sv3_azimuth;
    uint32_t valid_sv3_snr;
    uint32_t sv3_snr;

    uint32_t valid_sv4_prn;
    uint32_t sv4_prn;
    uint32_t valid_sv4_elevation;
    double sv4_elevation;
    uint32_t valid_sv4_azimuth;
    double sv4_azimuth;
    uint32_t valid_sv4_snr;
    uint32_t sv4_snr;
};

struct gpgsv gpgsv_data;

void gpgsv_parse(char *info)
{
    printf("%s\n", __FUNCTION__);

    memset(&gpgsv_data, sizeof(gpgsv_data), 0);

    char *p1, *p2;

    // GNSS_GPGSV_NUMBER_OF_MESSAGES
    p1 = &info[1 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsv_data.valid_number_of_messages = VALID;
        gpgsv_data.number_of_messages = atoi(p1);

        printf("%s:%d\n", STR(gpgsv_data.number_of_messages), gpgsv_data.number_of_messages);
    }
    else
    {
        gpgsv_data.valid_number_of_messages = INVALID;
    }

    // GNSS_GPGSV_MESSAGE_NUMBER
    p1 = &info[2 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsv_data.valid_message_number = VALID;
        gpgsv_data.message_number = atoi(p1);

        printf("%s:%d\n", STR(gpgsv_data.message_number), gpgsv_data.message_number);
    }
    else
    {
        gpgsv_data.valid_message_number = INVALID;
    }

    // GNSS_GPGSV_TOTAL_NUMBER_OF_SVS
    p1 = &info[3 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsv_data.valid_total_number_of_svs = VALID;
        gpgsv_data.total_number_of_svs = atoi(p1);

        printf("%s:%d\n", STR(gpgsv_data.total_number_of_svs), gpgsv_data.total_number_of_svs);
    }
    else
    {
        gpgsv_data.valid_total_number_of_svs = INVALID;
    }

    // GNSS_GPGSV_SV1_PRN
    p1 = &info[4 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsv_data.valid_sv1_prn = VALID;
        gpgsv_data.sv1_prn = atoi(p1);

        printf("%s:%d\n", STR(gpgsv_data.sv1_prn), gpgsv_data.sv1_prn);
    }
    else
    {
        gpgsv_data.valid_sv1_prn = INVALID;
    }

    // GNSS_GPGSV_SV1_ELEVATION
    p1 = &info[5 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsv_data.valid_sv1_elevation = VALID;
        gpgsv_data.sv1_elevation = atof(p1);

        printf("%s:%f\n", STR(gpgsv_data.sv1_elevation), gpgsv_data.sv1_elevation);
    }
    else
    {
        gpgsv_data.valid_sv1_elevation = INVALID;
    }

    // GNSS_GPGSV_SV1_AZIMUTH
    p1 = &info[6 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsv_data.valid_sv1_azimuth = VALID;
        gpgsv_data.sv1_azimuth = atof(p1);

        printf("%s:%f\n", STR(gpgsv_data.sv1_azimuth), gpgsv_data.sv1_azimuth);
    }
    else
    {
        gpgsv_data.valid_sv1_azimuth = INVALID;
    }

    // GNSS_GPGSV_SV1_SNR
    p1 = &info[7 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsv_data.valid_sv1_snr = VALID;
        gpgsv_data.sv1_snr = atoi(p1);

        printf("%s:%d\n", STR(gpgsv_data.sv1_snr), gpgsv_data.sv1_snr);
    }
    else
    {
        gpgsv_data.valid_sv1_snr = INVALID;
    }

    // GNSS_GPGSV_SV2_PRN
    p1 = &info[8 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsv_data.valid_sv2_prn = VALID;
        gpgsv_data.sv2_prn = atoi(p1);

        printf("%s:%d\n", STR(gpgsv_data.sv2_prn), gpgsv_data.sv2_prn);
    }
    else
    {
        gpgsv_data.valid_sv2_prn = INVALID;
    }

    // GNSS_GPGSV_SV2_ELEVATION
    p1 = &info[9 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsv_data.valid_sv2_elevation = VALID;
        gpgsv_data.sv2_elevation = atof(p1);

        printf("%s:%f\n", STR(gpgsv_data.sv2_elevation), gpgsv_data.sv2_elevation);
    }
    else
    {
        gpgsv_data.valid_sv2_elevation = INVALID;
    }

    // GNSS_GPGSV_SV2_AZIMUTH
    p1 = &info[10* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsv_data.valid_sv2_azimuth = VALID;
        gpgsv_data.sv2_azimuth = atof(p1);

        printf("%s:%f\n", STR(gpgsv_data.sv2_azimuth), gpgsv_data.sv2_azimuth);
    }
    else
    {
        gpgsv_data.valid_sv2_azimuth = INVALID;
    }

    // GNSS_GPGSV_SV2_SNR
    p1 = &info[11* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsv_data.valid_sv2_snr = VALID;
        gpgsv_data.sv2_snr = atoi(p1);

        printf("%s:%d\n", STR(gpgsv_data.sv2_snr), gpgsv_data.sv2_snr);
    }
    else
    {
        gpgsv_data.valid_sv2_snr = INVALID;
    }

    // GNSS_GPGSV_SV3_PRN
    p1 = &info[12* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsv_data.valid_sv3_prn = VALID;
        gpgsv_data.sv3_prn = atoi(p1);

        printf("%s:%d\n", STR(gpgsv_data.sv3_prn), gpgsv_data.sv3_prn);
    }
    else
    {
        gpgsv_data.valid_sv3_prn = INVALID;
    }

    // GNSS_GPGSV_SV3_ELEVATION
    p1 = &info[13* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsv_data.valid_sv3_elevation = VALID;
        gpgsv_data.sv3_elevation = atof(p1);

        printf("%s:%f\n", STR(gpgsv_data.sv3_elevation), gpgsv_data.sv3_elevation);
    }
    else
    {
        gpgsv_data.valid_sv3_elevation = INVALID;
    }

    // GNSS_GPGSV_SV3_AZIMUTH
    p1 = &info[14* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsv_data.valid_sv3_azimuth = VALID;
        gpgsv_data.sv3_azimuth = atof(p1);

        printf("%s:%f\n", STR(gpgsv_data.sv3_azimuth), gpgsv_data.sv3_azimuth);
    }
    else
    {
        gpgsv_data.valid_sv3_azimuth = INVALID;
    }

    // GNSS_GPGSV_SV3_SNR
    p1 = &info[15* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsv_data.valid_sv3_snr = VALID;
        gpgsv_data.sv3_snr = atoi(p1);

        printf("%s:%d\n", STR(gpgsv_data.sv3_snr), gpgsv_data.sv3_snr);
    }
    else
    {
        gpgsv_data.valid_sv3_snr = INVALID;
    }

    // GNSS_GPGSV_SV4_PRN
    p1 = &info[16* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsv_data.valid_sv4_prn = VALID;
        gpgsv_data.sv4_prn = atoi(p1);

        printf("%s:%d\n", STR(gpgsv_data.sv4_prn), gpgsv_data.sv4_prn);
    }
    else
    {
        gpgsv_data.valid_sv4_prn = INVALID;
    }

    // GNSS_GPGSV_SV4_ELEVATION
    p1 = &info[17* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsv_data.valid_sv4_elevation = VALID;
        gpgsv_data.sv4_elevation = atof(p1);

        printf("%s:%f\n", STR(gpgsv_data.sv4_elevation), gpgsv_data.sv4_elevation);
    }
    else
    {
        gpgsv_data.valid_sv4_elevation = INVALID;
    }

    // GNSS_GPGSV_SV4_AZIMUTH
    p1 = &info[18* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsv_data.valid_sv4_azimuth = VALID;
        gpgsv_data.sv4_azimuth = atof(p1);

        printf("%s:%f\n", STR(gpgsv_data.sv4_azimuth), gpgsv_data.sv4_azimuth);
    }
    else
    {
        gpgsv_data.valid_sv4_azimuth = INVALID;
    }

    // GNSS_GPGSV_SV4_SNR
    p1 = &info[19* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgsv_data.valid_sv4_snr = VALID;
        gpgsv_data.sv4_snr = atoi(p1);

        printf("%s:%d\n", STR(gpgsv_data.sv4_snr), gpgsv_data.sv4_snr);
    }
    else
    {
        gpgsv_data.valid_sv4_snr = INVALID;
    }
}

struct gprmc
{
    uint32_t valid_utc;
    double utc;
    uint32_t valid_fix_quality;
    uint32_t fix_quality;
    uint32_t valid_latitude;
    double latitude;
    uint32_t valid_longitude;
    double longitude;
    uint32_t valid_speed;
    double speed;
    uint32_t valid_azimuth;
    double azimuth;
    uint32_t valid_magnetic_declination;
    double magnetic_declination;
};

struct gprmc gprmc_data;

void gprmc_parse(char *info)
{
    printf("%s\n", __FUNCTION__);

    memset(&gprmc_data, sizeof(gprmc_data), 0);

    char *p1, *p2;

    // GNSS_GPRMC_UTC
    p1 = &info[1 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gprmc_data.valid_utc = VALID;
        gprmc_data.utc = atof(p1);

        printf("%s:%f\n", STR(gprmc_data.utc), gprmc_data.utc);
    }
    else
    {
        gprmc_data.valid_utc = INVALID;
    }

    // GNSS_GPRMC_FIX_QUALITY
    p1 = &info[2 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gprmc_data.valid_fix_quality = VALID;
        gprmc_data.fix_quality = p1[0];

        printf("%s:%c\n", STR(gprmc_data.fix_quality), gprmc_data.fix_quality);
    }
    else
    {
        gprmc_data.valid_fix_quality = INVALID;
    }

    // GNSS_GPRMC_LATITUDE
    p1 = &info[3 * NMEA_INFO_LEN];
    p2 = &info[4 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gprmc_data.valid_latitude = VALID;
        gprmc_data.latitude = atof(p1);

        char c = p2[0];

        if ('N' == c)
        {
            gprmc_data.latitude = gprmc_data.latitude;
        }
        else if ('S' == c)
        {
            gprmc_data.latitude =-gprmc_data.latitude;
        }
        else
        {
            // do_nothing();
        }

        printf("%s:%f\n", STR(gprmc_data.latitude), gprmc_data.latitude);
    }
    else
    {
        gprmc_data.valid_latitude = INVALID;
    }

    // GNSS_GPRMC_LONGITUDE
    p1 = &info[5 * NMEA_INFO_LEN];
    p2 = &info[6 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gprmc_data.valid_longitude = VALID;
        gprmc_data.longitude = atof(p1);

        char c = p2[0];

        if ('E' == c)
        {
            gprmc_data.longitude = gprmc_data.longitude;
        }
        else if ('W' == c)
        {
            gprmc_data.longitude =-gprmc_data.longitude;
        }
        else
        {
            // do_nothing();
        }

        printf("%s:%f\n", STR(gprmc_data.longitude), gprmc_data.longitude);
    }
    else
    {
        gprmc_data.valid_longitude = INVALID;
    }

    // GNSS_GPRMC_SPEED
    p1 = &info[7 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gprmc_data.valid_speed = VALID;
        gprmc_data.speed = atof(p1);

        printf("%s:%f\n", STR(gprmc_data.speed), gprmc_data.speed);
    }
    else
    {
        gprmc_data.valid_speed = INVALID;
    }

    // GNSS_GPRMC_AZIMUTH
    p1 = &info[8 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gprmc_data.valid_azimuth = VALID;
        gprmc_data.azimuth = atof(p1);

        printf("%s:%f\n", STR(gprmc_data.azimuth), gprmc_data.azimuth);
    }
    else
    {
        gprmc_data.valid_azimuth = INVALID;
    }

    // UTC DATE
    p1 = &info[9 * NMEA_INFO_LEN];
    
    if (strlen(p1))
    {
        printf("%s:%d\n", STR(UTC.DATE), atoi(p1));
    }

    // GNSS_GPRMC_MAGNETIC_DECLINATION
    p1 = &info[10* NMEA_INFO_LEN];
    p2 = &info[11* NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gprmc_data.valid_magnetic_declination = VALID;
        gprmc_data.magnetic_declination = atof(p1);

        char c = p2[0];

        if ('E' == c)
        {
            ;
        }
        else if ('W' == c)
        {
            ;
        }
        else
        {
            // do_nothing();
        }

        printf("%s:%f\n", STR(gprmc_data.magnetic_declination), gprmc_data.magnetic_declination);
    }
    else
    {
        gprmc_data.valid_magnetic_declination = INVALID;
    }
}

struct gpvtg
{
    uint32_t valid_t_motion_angle;
    double t_motion_angle;
    uint32_t valid_m_motion_angle;
    double m_motion_angle;

    uint32_t valid_n_hor_movement_speed;
    double n_hor_movement_speed;
    uint32_t valid_k_hor_movement_speed;
    double k_hor_movement_speed;
};

struct gpvtg gpvtg_data;

void gpvtg_parse(char *info)
{
    printf("%s\n", __FUNCTION__);

    memset(&gpvtg_data, sizeof(gpvtg_data), 0);

    char *p1, *p2;

    // GNSS_GPVTG_T_MOTION_ANGLE
    p1 = &info[1 * NMEA_INFO_LEN];
    p2 = &info[2 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpvtg_data.valid_t_motion_angle = VALID;
        gpvtg_data.t_motion_angle = atof(p1);

        char c = p2[0];

        if ('T' == c)
        {
            // do_nothing();
        }

        printf("%s:%f\n", STR(gpvtg_data.t_motion_angle), gpvtg_data.t_motion_angle);
    }
    else
    {
        gpvtg_data.valid_t_motion_angle = INVALID;
    }

    // GNSS_GPVTG_M_MOTION_ANGLE
    p1 = &info[3 * NMEA_INFO_LEN];
    p2 = &info[4 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpvtg_data.valid_m_motion_angle = VALID;
        gpvtg_data.m_motion_angle = atof(p1);

        char c = p2[0];

        if ('M' == c)
        {
            // do_nothing();
        }

        printf("%s:%f\n", STR(gpvtg_data.m_motion_angle), gpvtg_data.m_motion_angle);
    }
    else
    {
        gpvtg_data.valid_m_motion_angle = INVALID;
    }

    // GNSS_GPVTG_N_HOR_MOVEMENT_SPEED
    p1 = &info[5 * NMEA_INFO_LEN];
    p2 = &info[6 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpvtg_data.valid_n_hor_movement_speed = VALID;
        gpvtg_data.n_hor_movement_speed = atof(p1);

        char c = p2[0];

        if ('N' == c)
        {
            // do_nothing();
        }

        printf("%s:%f\n", STR(gpvtg_data.n_hor_movement_speed), gpvtg_data.n_hor_movement_speed);
    }
    else
    {
        gpvtg_data.valid_n_hor_movement_speed = INVALID;
    }

    // GNSS_GPVTG_K_HOR_MOVEMENT_SPEED
    p1 = &info[7 * NMEA_INFO_LEN];
    p2 = &info[8 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpvtg_data.valid_k_hor_movement_speed = VALID;
        gpvtg_data.k_hor_movement_speed = atof(p1);

        char c = p2[0];

        if ('N' == c)
        {
            // do_nothing();
        }

        printf("%s:%f\n", STR(gpvtg_data.k_hor_movement_speed), gpvtg_data.k_hor_movement_speed);
    }
    else
    {
        gpvtg_data.valid_k_hor_movement_speed = INVALID;
    }
}

struct gpgll
{
    uint32_t valid_latitude;
    double latitude;
    uint32_t valid_longitude;
    double longitude;
    uint32_t valid_utc;
    double utc;
    uint32_t valid_fix_quality;
    uint32_t fix_quality;
};

struct gpgll gpgll_data;

void gpgll_parse(char *info)
{
    printf("%s\n", __FUNCTION__);

    memset(&gpgll_data, sizeof(gpgll_data), 0);

    char *p1, *p2;

    // GNSS_GPGLL_LATITUDE
    p1 = &info[1 * NMEA_INFO_LEN];
    p2 = &info[2 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgll_data.valid_latitude = VALID;
        gpgll_data.latitude = atof(p1);

        char c = p2[0];

        if ('N' == c)
        {
            gpgll_data.latitude = gpgll_data.latitude;
        }
        else if ('S' == c)
        {
            gpgll_data.latitude =-gpgll_data.latitude;
        }
        else
        {
            // do_nothing();
        }

        printf("%s:%f\n", STR(gpgll_data.latitude), gpgll_data.latitude);
    }
    else
    {
        gpgll_data.valid_latitude = INVALID;
    }

    // GNSS_GPGLL_LONGITUDE
    p1 = &info[3 * NMEA_INFO_LEN];
    p2 = &info[4 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgll_data.valid_longitude = VALID;
        gpgll_data.longitude = atof(p1);

        char c = p2[0];

        if ('E' == c)
        {
            gpgll_data.longitude = gpgll_data.longitude;
        }
        else if ('W' == c)
        {
            gpgll_data.longitude =-gpgll_data.longitude;
        }
        else
        {
            // do_nothing();
        }

        printf("%s:%f\n", STR(gpgll_data.longitude), gpgll_data.longitude);
    }
    else
    {
        gpgll_data.valid_longitude = INVALID;
    }

    // GNSS_GPGLL_UTC
    p1 = &info[5 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgll_data.valid_utc = VALID;
        gpgll_data.utc = atof(p1);

        printf("%s:%f\n", STR(gpgll_data.utc), gpgll_data.utc);
    }
    else
    {
        gpgll_data.valid_utc = INVALID;
    }

    // GNSS_GPGLL_FIX_QUALITY
    p1 = &info[6 * NMEA_INFO_LEN];

    if (strlen(p1))
    {
        gpgll_data.valid_fix_quality = VALID;
        gpgll_data.fix_quality = p1[0];

        printf("%s:%c\n", STR(gpgll_data.fix_quality), gpgll_data.fix_quality);
    }
    else
    {
        gpgll_data.valid_fix_quality = INVALID;
    }
}
xlbtlmy
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
GPS(NMEA)数据解析
weixin_33739646的博客
09-14 2141
一、GPS定位信息设置好gps模式，启动gps,正常的话在gps通路有NMEA数据上报，如下：$GPGSV,3,1,11,01,62,130,42,07,61,201,43,11,72,075,28,17,20,251,38*7A$GPGSV,3,2,11,30,63,272,44,03,00,149,,08,34,046,,13,05,309,*76$GPGSV,3,3,1...
GPS NMEA0183协议解析
gfuugfd的博客
11-10 1499
GPS NMEA0183协议解析
【基于Matlab的NMEA数据-GPS采集与可视化】保姆级教程 | NMEA数据集自定义制作 | NMEA数据解析 | NMEA-GPS数据可视化 | 全过程图文by.Akaxi
最新发布
Akaxi的博客
05-07 1175
【基于Matlab的NMEA数据-GPS采集与可视化】保姆级教程 | NMEA数据集自定义制作 | NMEA数据解析 | NMEA-GPS数据可视化 | 全过程图文by.Akaxi
GPS NMEA-0183协议常用数据格式及解析攻略
welcome_yu的博客
08-20 1万+
GPS协议标准目前常用到的是NMEA-0183，很显然，这是由NMEA发布的一个标准。 NMEA是National Marine Electronics Association ，即美国国家海洋电子协会的缩写，NMEA是GPS的管理者，为方便GPS的推广应用，发布了一系列GPS协议的标准格式。 NMEA-0183就是GPS协议标准的一个，它的早期版本为NMEA-0180和NMEA-0182。虽然它现在仍然用得很多，但时光的车轮在前进，它将会逐渐被最新的NMEA 2000所替代。 NMEA－183是一个基于A
GPS NMEA-0183协议详解
weichun1121的博客
06-21 2711
一、 NMEA0183标准语句(GPS常用语句) $GPGGA 例：$GPGGA,092204.999,4250.5589,S,14718.5084,E,1,04,24.4,19.7,M,,,,0000*1F 字段0：$GPGGA，语句ID，表明该语句为Global Positioning System Fix Data（GGA）GPS定位信息 ...
gps nmea数据格式解析与生成
深之JohnChen的专栏
12-11 8603
一、nmea数据格式介绍 nmea数据如下：  $GPGGA,025620.00,2602.33721,N,11911.49176,E,2,04,1.63,13.5,M,9.9,M,,0000*5D $GPRMC,121252.000,A,3958.3032,N,11629.6046,E,15.15,359.95,070306,,,A*54  $GNRMC,230134.00,A,2237.124...
从NMEA0183到GNSS定位数据获取（二）软件篇
ba_wang_mao的专栏
10-31 1374
从NMEA0183到GNSS定位数据获取（二）软件篇
GNSS NMEA-0183协议解析
热门推荐
凡人叶枫的博客
12-24 1万+
最近在做gps相关工作，需要解析gps模组输出的nmea数据，获得经纬度等信息，整理了一下nmea各个字段的含义，供大家参考。 基本介绍 GNSS的全称是全球导航卫星系统（Global Navigation Satellite System），它是泛指所有的卫星导航系统，包括全球的、区域的和增强的，如美国的GPS、俄罗斯的Glonass、欧洲的Galileo、中国的北斗卫星导航系统，以及相关的增强系统，如美国的WAAS（广域增强系统）、欧洲的EGNOS（欧洲静地导航重叠系统）和日本的MSAS（多功能运输卫星
NMEA0183协议详细解析(GPS、北斗、GNSS)
_
09-22 1万+
1.（GGA）GPS定位信息 Global Positioning System Fix Data $GNGGA,<1>,<2>,<3>,<4>,<5>,<6>,<7>,<8>,<9>,M,<10>,M,<11>,<12>*hh <1> 023229.000：UTC时间，hhmmss.fff（时分秒.毫秒）格式 <2> 3640.6001：纬
GPS数据协议NMEA-0183附解析代码
u012572552的博客
11-28 6574
         NMEA 0183是美国国家海洋电子协会（National Marine Electronics  Association ）为海用电子设备制定的标准格式。 注：发送次序$PZDA、$GPGGA、$GPGLL、$GPVTG、$GPGSA、$GPGSV*3、$GPRMC 解析代码下载：https://download.csdn.net/download/u012572552...
GPS NMEA-0183数据解析代码
11-28
NMEA-0183协议定义的语句非常多，但是常用的或者说兼容性最广的语句只有$GPGGA、$GPGSA、$GPGSV、$GPRMC、$GPVTG、$GPGLL等。本代码提供数据解析方法，语句格式详解见 ...
NMEA0183完整版.pdf
08-21
NMEA0183协议是GPS数据处理中不可或缺的参考资料，提供了各种GPS数据格式用于处理和分析GPS数据。本文将详细介绍NMEA0183协议的知识点。 一、NMEA0183协议简介 NMEA0183协议是一个行业标准，用于定义GPS设备与主机...
NMEA0183GPS数据协议解析
11-07
通过将获取到$""数据输入函数中，得到解析后的数据，包括角度、时间、十进制的经纬度数据等，可以根据不通的指令选择不同的数据解析。代码通过C语言编写，可以通过vs生成动态库文件，通过C++或者C#调用。
GPS串口协议解析(nmea0183)
12-15
**数据解析：** 在接收到NMEA句子后，需要解析数据字段，例如，将经纬度从度分秒格式转换为十进制格式，校验数据的完整性和有效性，提取出速度、方向、时间等关键信息。 **编程实现：** 描述中提到的压缩包文件可能...
NMEA 0183数据解析协议
10-16
介绍GPS模块的NMEA0183数据协议，帮助使用者快速解析数据
位反转算法
xlbtlmy的博客
07-19 2036
u8 bit_rev(u8 origin) { static u8 rev_tbl[16] ={ 0x00, 0x08, 0x04, 0x0C, 0x02, 0x0A, 0x06, 0x0E, 0x01, 0x09, 0x05, 0x0D, 0x03, 0...
循环缓冲队列(ringbuf)
xlbtlmy的博客
07-19 1506
#ifndef _RINGBUF_H_ #define _RINGBUF_H_ #define MAX_RINGBUF_SIZE_UART (170 + 1) #define RW_SIZE 8 typedef unsigned char u8; typedef unsigned short u16; typedef unsigned long u32; typedef...
循环冗余校验(Cyclic Redundancy Check)算法
xlbtlmy的博客
07-19 1356
#ifndef _CRC32_H_ #define _CRC32_H_ /* * 循环冗余校验(Cyclic Redundancy Check, CRC) */ typedef unsigned char u8; typedef unsigned short u16; typedef unsigned long u32; #define ARRAY_SIZE(x) ((size...
GPS的NMEA 0183解析
05-26
NMEA 0183是一种标准的串行通信协议，用于GPS接收机与其他...要解析NMEA 0183数据，通常需要使用特定的解析库或程序。这些库或程序可以将数据分割成不同的字段，并将它们转换成易于读取和处理的格式，例如JSON或CSV。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值