Main Content

Esta página se ha traducido mediante traducción automática. Haga clic aquí para ver la última versión en inglés.

nmeaParser

Analizar datos de sentencias NMEA estándar y específicas del fabricante enviadas desde dispositivos electrónicos marinos.

Desde R2020b

expandir todo en la página

Descripción

El nmeaParser System object™ analiza datos de cualquier sentencia NMEA (Asociación Nacional de Electrónica Marina). Las sentencias que necesitan análisis de datos pueden ser cualquier sentencia estándar que cumpla con las especificaciones NMEA 0183® (que se envían desde un receptor GNSS (Sistema global de navegación por satélite)) u otras sentencias específicas del fabricante aprobadas por el NMEA (que se envían desde otros dispositivos electrónicos marinos).

El nmeaParser System object proporciona:

  • Soporte integrado para analizar datos enviados desde receptores GNSS e identificados por estos nueve tipos de mensajes NMEA: RMC, GGA, GSA, VTG, GLL, GST, ZDA, GSV y HDT

  • Configuración adicional utilizando el par nombre-valor CustomSentence para analizar datos NMEA de múltiples categorías de dispositivos, incluidas sentencias específicas de diferentes fabricantes de hardware.

Para analizar datos de sentencias NMEA:

  1. Cree el objeto nmeaParser y establezca sus propiedades.

  2. Llame al objeto con argumentos, como si fuera una función.

Para obtener más información sobre cómo funcionan los System objects, consulte What Are System Objects?

El nmeaParser System object genera un arreglo de estructuras correspondientes a los valores extraídos de las sentencias NMEA especificadas.

Creación

Sintaxis

pnmea = nmeaParser
pnmea = nmeaParser("MessageIDs", 'msgID')
pnmea = nmeaParser("CustomSentence", {['CustomMessageId1','parserFunctionName1'],['CustomMessageId2','parserFunctionName2']})
pnmea = nmeaParser("MessageIDs", {'msgID1','msgID2'},"CustomSentence", {['CustomMessageId1','parserFunctionName1'],['CustomMessageId2','parserFunctionName2']})

Descripción

pnmea = nmeaParser devuelve un nmeaParser System object, pnmea, con propiedades predeterminadas, que extrae datos de estos estándares Mensajes NMEA: RMC, GGA y GSA. El orden de los arreglos de estructura en los datos de salida extraídos también es: RMC, GGA y GSA.

ejemplo

pnmea = nmeaParser("MessageIDs", 'msgID') devuelve un nmeaParser System object, pnmea, que extrae datos de uno de los nueve estándares NMEA mensajes con soporte integrado, especificados mediante los ID de mensaje. Especifique msgID como "RMC", "GGA", "GSA", "GSV", "VTG", "GLL", "GST", "ZDA" y "HDT" o una combinación de estos ID (por ejemplo: ["VTG","GLL","HDT"]). El orden en el que especifica los ID de mensaje determina el orden de los arreglos de estructura en los datos de salida extraídos. El valor predeterminado es ["RMC","GGA","GSA"].

ejemplo

pnmea = nmeaParser("CustomSentence", {['CustomMessageId1','parserFunctionName1'],['CustomMessageId2','parserFunctionName2']}) establece propiedades usando el par nombre-valor CustomSentence y devuelve un nmeaParser System object, pnmea, que extrae datos de cualquier mensaje NMEA personalizado (ya sea un mensaje NMEA estándar o un mensaje NMEA específico del fabricante), especificado mediante los ID de mensaje.

El par nombre-valor CustomSentence acepta un arreglo de celdas anidadas donde cada elemento es un par de nombre de ID de mensaje (ya sea nombre de ID de mensaje NMEA estándar o ID de mensaje específico del fabricante) y la función de analizador correspondiente definido por el usuario, que se crea incluyendo la función extractNMEASentence en un archivo de función. El orden en el que especifica los ID de los mensajes determina el orden de los arreglos de estructura en los datos de salida extraídos.

ejemplo

pnmea = nmeaParser("MessageIDs", {'msgID1','msgID2'},"CustomSentence", {['CustomMessageId1','parserFunctionName1'],['CustomMessageId2','parserFunctionName2']}) devuelve un nmeaParser System object, pnmea, que extrae datos de dos de los nueve mensajes NMEA estándar con soporte integrado y también de mensajes NMEA personalizados que haya especificado utilizando el par nombre-valor CustomSentence .

Argumentos de entrada

expandir todo

Argumentos de par nombre-valor

Especifique pares de argumentos opcionales como Name1=Value1,...,NameN=ValueN, donde Name es el nombre del argumento y Value es el valor correspondiente. Los argumentos nombre-valor deben aparecer después de los otros argumentos, pero el orden de los pares no importa.

Antes de R2021a, utilice comas para separar cada nombre y valor, y encierre Name entre comillas.

Ejemplo: pnmea = nmeaParser("CustomSentence", {['CustomMessageId1','parserFunctionName1'],['CustomMessageId2','parserFunctionName2']});

Especifique el ID del mensaje de cualquier sentencia NMEA de la que desee extraer datos y el nombre de la función del analizador. Puede especificar varios ID de mensajes y funciones de analizador como un arreglo de celdas de vectores de caracteres. La función del analizador se define en un archivo de función, que opcionalmente puede incluir la función extractNMEASentence .

Nota

El archivo de función para la función del analizador debe estar presente en el directorio actual o en la ruta de MATLAB .

CustomSentence acepta el nombre de la función o el identificador de la función. Por ejemplo, ambos formatos son válidos:

  • pnmea = nmeaParser('CustomSentence', {['standardnmeaMessageId1','parserFunctionName1']}
  • parserFunctionHandle=@parserFunctionName1
pnmea = nmeaParser('CustomSentence', {['standardnmeaMessageId1',parserFunctionHandle]}

Nota

El uso de CustomSentence par nombre-valor para analizar datos en lugar de la función de analizador incorporada da como resultado la anulación de los campos predeterminados cuando se analizan los datos. Por ejemplo, nmeaParser('CustomSentence',{["RMC","parserRMC"]}) anula el formato predeterminado de los datos analizados, ya que RMC es una de las nueve sentencias con soporte integrado para analizar datos.

Tipos de datos: char | string

Propiedades

expandir todo

A menos que se indique lo contrario, las propiedades son no ajustables, lo que significa que no se pueden cambiar sus valores después de llamar al objeto. Los objetos se bloquean cuando los llamas y la función release los desbloquea.

Si una propiedad es ajustable, puedes cambiar su valor en cualquier momento.

Para obtener más información sobre cómo cambiar los valores de las propiedades, consulte System Design in MATLAB Using System Objects.

ID de mensajes de nueve sentencias NMEA con soporte integrado, que cumplen con el estándar NMEA 0183 , del cual desea extraer datos. Puede especificar varios ID de mensajes como un arreglo de cadenas para extraer datos de sentencias NMEA.

Tipos de datos: char | string

Uso

Sintaxis

[rmcData,ggaData,gsaData,vtgData,gllData,gstData,gsvData,zdaData,hdtData] = pnmea(rawData)
[customNmeaData1,customNmeaData2] = pnmea(rawData)

Descripción

ejemplo

[rmcData,ggaData,gsaData,vtgData,gllData,gstData,gsvData,zdaData,hdtData] = pnmea(rawData) analiza datos de nueve sentencias NMEA estándar con soporte integrado y devuelve un arreglo de estructuras, donde cada estructura corresponde a un único ID de mensaje. La secuencia que especifique para los argumentos de salida debe ser la misma secuencia que especificó para los ID de mensajes al crear el nmeaParser System object.

ejemplo

[customNmeaData1,customNmeaData2] = pnmea(rawData) analiza datos de dos sentencias NMEA personalizadas (ya sea una sentencia NMEA estándar o una sentencia NMEA específica del fabricante) y devuelve un arreglo de estructuras, donde cada estructura corresponde a un único ID de mensaje. La secuencia que especifique para los argumentos de salida debe ser la misma secuencia que especificó en el par nombre-valor CustomSentence al crear el nmeaParser System object.

Argumentos de entrada

expandir todo

Datos NMEA, que cumplen con el estándar NMEA, obtenidos de un dispositivo electrónico marino.

Tipos de datos: string | char

Argumentos de salida

expandir todo

Datos extraídos de una sentencia RMC. La estructura de salida contiene la información analizada de una sentencia RMC junto con el estado del análisis. Si se encuentran varias sentencias RMC en los datos de entrada, se devuelve un arreglo de estructuras. Para obtener más detalles, consulte Sentencias RMC.

Datos extraídos de una sentencia GGA. La estructura de salida contiene la información analizada de una sentencia GGA junto con el estado del análisis. Si se encuentran varias sentencias GGA en los datos de entrada, se devuelve un arreglo de estructuras. Para obtener más detalles, consulte Sentencias GGA.

Datos extraídos de una sentencia GSA. La estructura de salida contiene la información analizada de una sentencia GSA junto con el estado del análisis. Si se encuentran varias sentencias GSA en los datos de entrada, se devuelve un arreglo de estructuras. Para obtener más detalles, consulte Sentencias GSA.

Datos extraídos de una sentencia VTG. La estructura de salida contiene la información analizada de una sentencia VTG junto con el estado del análisis. Si se encuentran varias sentencias VTG en los datos de entrada, se devuelve un arreglo de estructuras. Para obtener más detalles, consulte Sentencias VTG.

Datos extraídos de una sentencia GLL. La estructura de salida contiene la información analizada de una sentencia GLL junto con el estado de análisis. Si se encuentran varias sentencias GLL en los datos de entrada, se devuelve un arreglo de estructuras. Para obtener más detalles, consulte Sentencias GLL.

Datos extraídos de una sentencia GST. La estructura de salida contiene la información analizada de una sentencia GST junto con el estado de análisis. Si se encuentran varias sentencias GST en los datos de entrada, se devuelve un arreglo de estructuras. Para obtener más detalles, consulte Sentencias GST.

Datos extraídos de una sentencia GSV. La estructura de salida contiene la información analizada de una sentencia GSV junto con el estado del análisis. La información completa del satélite está disponible en múltiples estructuras gsvData. Cada estructura gsvData puede tener un máximo de cuatro información de satélite. Para obtener más detalles, consulte Sentencias GSV.

Datos extraídos de una sentencia ZDA. La estructura de salida contiene la información analizada de una sentencia ZDA junto con el estado del análisis. Si se encuentran varias sentencias ZDA en los datos de entrada, se devuelve un arreglo de estructuras. Para obtener más detalles, consulte Sentencias ZDA.

Datos extraídos de una sentencia HDT. La estructura de salida contiene la información analizada de una sentencia HDT junto con el estado de análisis. Si se encuentran varias sentencias HDT en los datos de entrada, se devuelve un arreglo de estructuras. Para obtener más detalles, consulte Sentencias HDT.

Datos extraídos de cualquier sentencia NMEA estándar o específica del fabricante. La estructura de salida contiene la información analizada de la sentencia personalizada junto con el estado del análisis. Si se encuentran varias sentencias del mismo tipo de mensaje NMEA en los datos de entrada, se devuelve un arreglo de estructuras.

Funciones del objeto

Para utilizar una función de objeto, especifique System object como primer argumento de entrada. Por ejemplo, para liberar recursos del sistema de un System object llamado obj, use esta sintaxis:

release(obj)

Ejemplos

contraer todo

Abrir script en vivo

Extraiga datos de cualquiera de las nueve sentencias NMEA estándar como parte del soporte integrado utilizando la propiedad MessageID. Los datos NMEA se obtienen de un receptor GNSS.

Extraer datos de la sentencia RMC

Cree un System object nmeaParser especificando el ID del mensaje como "RMC".

pnmea = nmeaParser("MessageID","RMC");

Proporcione la sentencia RMC obtenida del receptor GNSS como datos de entrada y extracción.

unparsedRMCLine='$GNRMC,143909.00,A,5107.0020216,N,11402.3294835,W,0.036,348.3,210307,0.0,E,A*31';
rmcData = pnmea(unparsedRMCLine)
rmcData = struct with fields:
             TalkerID: "GN"
            MessageID: "RMC"
            FixStatus: 'A'
             Latitude: 51.1167
            Longitude: -114.0388
          GroundSpeed: 0.0185
      TrueCourseAngle: 348.3000
          UTCDateTime: 21-Mar-2007 14:39:09.000
    MagneticVariation: 0
        ModeIndicator: 'A'
     NavigationStatus: "NA"
               Status: 0

Extraiga datos de múltiples tipos de mensajes NMEA

Proporcione sentencias GGA, GSA y RMC como entrada.

unparsedGGALine = ['$GPGGA,111357.771,5231.364,N,01324.240,E,1,12,1.0,0.0,M,0.0,M,,*69'];
unparsedGSALine = ['$GPGSA,A,3,01,02,03,04,05,06,07,08,09,10,11,12,1.0,1.0,1.0*30'];
unparsedRMCLine = ['$GPRMC,111357.771,A,5231.364,N,01324.240,E,10903,221.5,020620,000.0,W*44'];

Crea un arreglo de cadenas para incluir las tres sentencias.

rawNMEAData = [unparsedGGALine ,newline,  unparsedGSALine ,newline,  unparsedRMCLine]
rawNMEAData = 
    '$GPGGA,111357.771,5231.364,N,01324.240,E,1,12,1.0,0.0,M,0.0,M,,*69
     $GPGSA,A,3,01,02,03,04,05,06,07,08,09,10,11,12,1.0,1.0,1.0*30
     $GPRMC,111357.771,A,5231.364,N,01324.240,E,10903,221.5,020620,000.0,W*44'

Sin embargo, tenga en cuenta que sólo necesita extraer datos de sentencias GGA y GSA. Así que cree el System object nmeaParser 'pnmea' y especifique los ID de mensaje 'GGA' y 'GSA' como un arreglo de cadenas.

pnmea=nmeaParser("MessageIDs",["GGA","GSA"]);

Especifique los argumentos de salida de las tres sentencias para extraer los datos como estructuras.

[ggaData,gsaData] =  pnmea(rawNMEAData)
ggaData = struct with fields:
                          TalkerID: "GP"
                         MessageID: "GGA"
                           UTCTime: 11:13:57.771
                          Latitude: 52.5227
                         Longitude: 13.4040
                  QualityIndicator: 1
                NumSatellitesInUse: 12
                              HDOP: 1
                          Altitude: 0
                   GeoidSeparation: 0
             AgeOfDifferentialData: NaN
    DifferentialReferenceStationID: NaN
                            Status: 0


gsaData = struct with fields:
              TalkerID: "GP"
             MessageID: "GSA"
                  Mode: "A"
               FixType: 3
    SatellitesIDNumber: [1 2 3 4 5 6 7 8 9 10 11 12]
                  PDOP: 1
                  VDOP: 1
                  HDOP: 1
              SystemID: NaN
                Status: 0

El resultado anterior muestra que solo se extraen sentencias GGA y GSA en función de los ID de mensaje especificados como entrada.

Proporcione otra sentencia GGA como entrada adicional y extraiga datos. En este caso, no es necesario modificar el System object ya que el ID del mensaje no ha cambiado.

unparsedGGALine1='$GNGGA,001043.00,4404.14036,N,12118.85961,W,1,12,0.98,1113.0,M,-21.3,M,,*47'
unparsedGGALine1 = 
'$GNGGA,001043.00,4404.14036,N,12118.85961,W,1,12,0.98,1113.0,M,-21.3,M,,*47'

rawNMEAData = [unparsedGGALine ,newline,  unparsedGSALine ,newline,  unparsedGGALine1]
rawNMEAData = 
    '$GPGGA,111357.771,5231.364,N,01324.240,E,1,12,1.0,0.0,M,0.0,M,,*69
     $GPGSA,A,3,01,02,03,04,05,06,07,08,09,10,11,12,1.0,1.0,1.0*30
     $GNGGA,001043.00,4404.14036,N,12118.85961,W,1,12,0.98,1113.0,M,-21.3,M,,*47'


[ggaData,gsaData] =  pnmea(rawNMEAData)
ggaData=2×1 struct array with fields:
    TalkerID
    MessageID
    UTCTime
    Latitude
    Longitude
    QualityIndicator
    NumSatellitesInUse
    HDOP
    Altitude
    GeoidSeparation
    AgeOfDifferentialData
    DifferentialReferenceStationID
    Status


gsaData = struct with fields:
              TalkerID: "GP"
             MessageID: "GSA"
                  Mode: "A"
               FixType: 3
    SatellitesIDNumber: [1 2 3 4 5 6 7 8 9 10 11 12]
                  PDOP: 1
                  VDOP: 1
                  HDOP: 1
              SystemID: NaN
                Status: 0

Un estado de 0 indica que los datos se analizaron correctamente.

Extraer datos de la sentencia GSV

Cree un System object nmeaParser especificando el ID del mensaje como "GSV".

pnmea = nmeaParser("MessageID","GSV");

Proporcione la sentencia GSV obtenida del receptor GNSS como datos de entrada y extracción.

unparsedGSVLine='$GPGSV,3,3,10,32,69,205,41,46,47,215,39*79';
gsvData = pnmea(unparsedGSVLine)
gsvData = struct with fields:
            TalkerID: "GP"
           MessageID: "GSV"
        NumSentences: 3
      SentenceNumber: 3
    SatellitesInView: 10
         SatelliteID: [32 46]
           Elevation: [69 47]
             Azimuth: [205 215]
                 SNR: [41 39]
            SignalID: NaN
              Status: 0

Extraiga datos de múltiples sentencias GSV

Proporcione varias sentencias GSV como entrada.

unparsedGSVLine1 = '$GPGSV,3,1,10,01,,,31,03,28,325,40,10,,,33,12,20,047,30*70';
unparsedGSVLine2 = '$GPGSV,3,2,10,14,88,028,42,22,39,299,48,25,,,25,31,79,289,46*49';
unparsedGSVLine3 = '$GPGSV,3,3,10,32,69,205,41,46,47,215,39*79';

Cree un arreglo de cadenas para incluir las tres sentencias.

CRLF = [char(13),newline];
unparsedGSVLines = [unparsedGSVLine1,CRLF, unparsedGSVLine2, CRLF, unparsedGSVLine3];

Cree el System object nmeaParser 'pnmea', especifique el ID del mensaje 'GSV' y extraiga los datos.

pnmea = nmeaParser("MessageIDs","GSV");
gsvData = pnmea(unparsedGSVLines)
gsvData=3×1 struct array with fields:
    TalkerID
    MessageID
    NumSentences
    SentenceNumber
    SatellitesInView
    SatelliteID
    Elevation
    Azimuth
    SNR
    SignalID
    Status

Leer datos del registro NMEA

Lea datos de un registro NMEA de muestra, para que los datos se puedan analizar utilizando el System object nmeaParser.

El archivo de registro de muestra es nmeaLog.nmea, que se incluye en este ejemplo.

f = fopen('nmeaLog.nmea');
unParsedNMEAdata = fread(f);
pnmea = nmeaParser("MessageIDs",["RMC","GGA"]);
[rmcStruct, ggaStruct] = pnmea(unParsedNMEAdata)
rmcStruct=9×1 struct array with fields:
    TalkerID
    MessageID
    FixStatus
    Latitude
    Longitude
    GroundSpeed
    TrueCourseAngle
    UTCDateTime
    MagneticVariation
    ModeIndicator
    NavigationStatus
    Status


ggaStruct=9×1 struct array with fields:
    TalkerID
    MessageID
    UTCTime
    Latitude
    Longitude
    QualityIndicator
    NumSatellitesInUse
    HDOP
    Altitude
    GeoidSeparation
    AgeOfDifferentialData
    DifferentialReferenceStationID
    Status
Abrir script en vivo

Puede extraer datos de cualquier sentencia NMEA utilizando el par nombre-valor CustomSentence . Los datos NMEA que se van a analizar se obtienen de dispositivos electrónicos marinos.

Identificar la estructura de la sentencia NMEA y crear la función de analizador

Debe identificar la estructura de la sentencia NMEA, tal como se define en la especificación, y usar esa información para definir la estructura de los datos de salida que se usarán en el System object nmeaParser.

Por ejemplo, consideremos una sentencia de ejemplo con ID de mensaje, SSS.

sss-sample1.png

Después de identificar la estructura, crea un archivo de función que define la función del analizador, fsssParser. En el archivo de función, usted define los datos de salida como un arreglo de estructura con sus campos que coinciden con la secuencia tal como aparece en la especificación.

Navigation Toolbox™ proporciona una función preconfigurada opcional, extractNMEASentence, que verifica si la sentencia es válida y convierte los campos de la sentencia en un arreglo de cadenas. Puede llamar a extractNMEASentence dentro del archivo de función. También puede usar cualquier otra función (que genera un arreglo de cadenas a partir de datos no analizados) y luego llamarla dentro del archivo de función.

La siguiente imagen muestra el archivo de función con el código, asumiendo que los campos disponibles en la sentencia SSS son TalkerID, MessageID, UTC y LatitudeError. Consulte los comentarios adicionales para obtener más detalles.

fsssparser-example1.png

En el archivo de muestra anterior, define la asignación entre los campos del arreglo de estructura y los elementos del arreglo de cadenas. Para ciertos campos (por ejemplo, hora UTC), es posible que necesite definir un arreglo de caracteres para asignar los campos.

Después de incluir el código MATLAB como se mencionó anteriormente, guarde el archivo de función (fsssParser.m) en la ruta de MATLAB , para que pueda llamarlo para obtener datos analizados usando el nombre-valor CustomSentence par de System object nmeaParser.

Para descargar otro archivo de función de muestra parserRMB.m que se utiliza en este ejemplo, haga clic en Abrir Live Script. Este es un archivo de función específico para los campos de una sentencia RMB (mencionada en el estándar NMEA, versión 4.1).

Extraer datos de la sentencia RMB

Cree un System object nmeaParser utilizando el par nombre-valor de CustomSentence y especificando el ID del mensaje como "RMB" y la función como "parserRMB" (descargado en el paso anterior).

pnmea = nmeaParser("CustomSentence",{["RMB","parserRMB"]});

Proporcione la sentencia RMB obtenida del receptor GNSS como datos de entrada y extracción.

unparsedRMBLine='$GPRMB,A,4.08,L,EGLL,EGLM,5130.02,N,00046.34,W,004.6,213.9,122.9,A*3D';
rmbData = pnmea(unparsedRMBLine)
rmbData = struct with fields:
                        TalkerID: "GP"
                       MessageID: "RMB"
                      DataStatus: 'A'
                 CrossTrackError: 4.0800
                DirectionToSteer: NaN
                OriginWaypointID: NaN
           DestinationWaypointID: NaN
     DestinationWaypointLatitude: '5130.02 N'
    DestinationWaypointLongitude: '00046.34 W'
              RangeToDestination: 4.6000
            BearingToDestination: 213.9000
      DestinationClosingVelocity: 122.9000
                   ArrivalStatus: 'A'
                   ModeIndicator: "NA"
                          Status: 0

Extraiga datos de varias sentencias en RMB

Proporcione varias sentencias RMB como entrada.

unparsedRMBLine1 = ['$GPRMB,A,0.66,L,003,004,4917.24,N,12309.57,W,001.3,052.5,000.5,V*20'];
unparsedRMBLine2 = ['$GPRMB,A,4.08,L,EGLL,EGLM,5130.02,N,00046.34,W,004.6,213.9,122.9,A*3D'];

Crea un arreglo de caracteres para incluir las dos sentencias.

rawNMEAData = [unparsedRMBLine1 ,newline,  unparsedRMBLine2]
rawNMEAData = 
    '$GPRMB,A,0.66,L,003,004,4917.24,N,12309.57,W,001.3,052.5,000.5,V*20
     $GPRMB,A,4.08,L,EGLL,EGLM,5130.02,N,00046.34,W,004.6,213.9,122.9,A*3D'

Especifique el argumento de salida de la sentencia RMB para extraer los datos.

[rmbData] =  pnmea(rawNMEAData)
rmbData=2×1 struct array with fields:
    TalkerID
    MessageID
    DataStatus
    CrossTrackError
    DirectionToSteer
    OriginWaypointID
    DestinationWaypointID
    DestinationWaypointLatitude
    DestinationWaypointLongitude
    RangeToDestination
    BearingToDestination
    DestinationClosingVelocity
    ArrivalStatus
    ModeIndicator
    Status

Extraiga datos de una sentencia con soporte integrado (RMC) y sentencia RMB

Cree un System object nmeaParser usando la propiedad MessageID (para analizar una sentencia con soporte integrado - RMC) y también usando el par nombre-valor CustomSentence (especificando el ID del mensaje como "RMB" y la función como "parserRMB" (creado en un paso previo)).

pnmea = nmeaParser("MessageID","RMC","CustomSentence",{["RMB","parserRMB"]});

Proporcione sentencias RMC y RMB como entrada.

unparsedRMCLine1 = ['$GNRMC,143909.00,A,5107.0020216,N,11402.3294835,W,0.036,348.3,210307,0.0,E,A*31'];
unparsedRMBLine2 = ['$GPRMB,A,4.08,L,EGLL,EGLM,5130.02,N,00046.34,W,004.6,213.9,122.9,A*3D'];

Crea un arreglo de cadenas para incluir las dos sentencias.

rawNMEAData = [unparsedRMCLine1 ,newline,  unparsedRMBLine2]
rawNMEAData = 
    '$GNRMC,143909.00,A,5107.0020216,N,11402.3294835,W,0.036,348.3,210307,0.0,E,A*31
     $GPRMB,A,4.08,L,EGLL,EGLM,5130.02,N,00046.34,W,004.6,213.9,122.9,A*3D'

Especifique el argumento de salida de la sentencia RMB para extraer los datos.

[rmcdata,rmbData] =  pnmea(rawNMEAData)
rmcdata = struct with fields:
             TalkerID: "GN"
            MessageID: "RMC"
            FixStatus: 'A'
             Latitude: 51.1167
            Longitude: -114.0388
          GroundSpeed: 0.0185
      TrueCourseAngle: 348.3000
          UTCDateTime: 21-Mar-2007 14:39:09.000
    MagneticVariation: 0
        ModeIndicator: 'A'
     NavigationStatus: "NA"
               Status: 0


rmbData = struct with fields:
                        TalkerID: "GP"
                       MessageID: "RMB"
                      DataStatus: 'A'
                 CrossTrackError: 4.0800
                DirectionToSteer: NaN
                OriginWaypointID: NaN
           DestinationWaypointID: NaN
     DestinationWaypointLatitude: '5130.02 N'
    DestinationWaypointLongitude: '00046.34 W'
              RangeToDestination: 4.6000
            BearingToDestination: 213.9000
      DestinationClosingVelocity: 122.9000
                   ArrivalStatus: 'A'
                   ModeIndicator: "NA"
                          Status: 0

  1. Identificar la estructura de una sentencia específica del fabricante y crear un archivo de función con la función de analizador

    La estructura de la sentencia NMEA que se va a analizar está disponible en las especificaciones del dispositivo del fabricante. Debe identificar la estructura y utilizar la información para definir la estructura de los datos de salida que se utilizarán en el System object nmeaParser.

    Por ejemplo, la estructura de la sentencia NMEA de un fabricante de hardware puede verse así:

    $PMMCZ,hhmmss.ss,Latitude,N,Longitude,E,NavSatellite,DR*hh<CR><LF>

    Aquí, P indica que la sentencia es específica del fabricante, MMC es el código mnemotécnico del fabricante y Z es el tipo de sentencia. A partir de entonces, cada campo indica un dato específico (posición, velocidad, tiempo, etc.). Algunos fabricantes utilizan dos caracteres para el tipo de sentencia, seguidos de los campos de datos.

    Después de identificar la estructura, cree la función de analizador, parserMMCZ, usando la función opcional extractNMEASentence , como se muestra a continuación (también puede usar otras funciones para extraer los datos no analizados a cadenas, en lugar de extractNMEASentence).

    function OutputData = parserMMCZ(unparsedData, MessageID)
 
  OutputData = struct("MessageID",MessageID,...
  "UTC","NA",...
  "Latitude",NaN,...
  "Longitude",NaN,...
  "NavigationSatellites",NaN,...
  "Status",uint8(1));
 
  [isValid, splitString] = extractNMEASentence(unparsedData, MessageID);
  
if(isValid)
    OutputData.MessageID = splitString(1);
    temp = char(splitString(2));
    utcOutput = [temp(1:2), ':', temp(3:4), ':', temp(5:6)];
    OutputData.UTC = utcOutput;
    OutputData.Latitude = str2double(splitString{3});
    OutputData.Longitude = str2double(splitString{5});
    OutputData.NavigationSatellites = str2double(splitString{7});
    OutputData.Status = uint8(0);
  end
end

    Guarde parserMMCZ.m en la ruta de MATLAB .

  2. Extraer datos de una sentencia específica del fabricante

    Cree un System object nmeaParser utilizando el par nombre-valor CustomSentence y especificando el ID del mensaje como "MMCZ" y la función como "parserMMCZ" (creada en la versión anterior). paso).

    pnmea = nmeaParser("CustomSentence",{["MMCZ","parserMMCZ"]});

    Proporcione una sentencia MMC obtenida del dispositivo como datos de entrada y extracción:

    unparsedMMCLine='$PMMCZ,225444,4917.24,N,00046.34,E,3,DR*7C';
mmcData = pnmea(unparsedMMCLine)
    mmcData = 

  struct with fields:

               MessageID: "MMCZ"
                     UTC: '22:54:44'
                Latitude: 4.9172e+03
               Longitude: 46.3400
    NavigationSatellites: 3
                  Status: 0

Más acerca de

expandir todo

Historial de versiones

Introducido en R2020b

Consulte también

|

Temas