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.

expandir todo en la página

Descripción

nmeaParser System object™ analiza datos de cualquier sentencia NMEA (Asociación Nacional de Electrónica Marina). Las oraciones que necesitan análisis de datos pueden ser cualquier oración estándar compatible con las especificaciones NMEA 0183® (que se envían desde un receptor GNSS (Sistema global de navegación por satélite)) u otras oraciones específicas del fabricante aprobadas por 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 que utiliza el par nombre-valor CustomSentence para analizar datos NMEA de múltiples categorías de dispositivos, incluidas sentencias específicas del fabricante de diferentes fabricantes de hardware

Para analizar datos de sentencias NMEA:

  1. Cree el objeto nmeaParser y configure sus propiedades.

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

Para más información sobre el funcionamiento de los System objects, consulte ¿Qué son los System Objects?

nmeaParser System object genera un arreglo de estructuras correspondientes a los valores extraídos de las oraciones 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 mensajes NMEA estándar: 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.

pnmea = nmeaParser("MessageIDs", 'msgID') devuelve un nmeaParser System object, pnmea, que extrae datos de uno de los nueve mensajes NMEA estándar con soporte integrado, especificados mediante los ID de mensajes. Especifique msgID como "RMC", "GGA", "GSA", "GSV", "VTG", "GLL", "GST", "ZDA" y "HDT", o una combinación de estos identificadores (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 utilizando 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 utilizando los ID de mensajes.

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 un nombre de ID de mensaje NMEA estándar o un ID de mensaje específico del fabricante) y la función de analizador definida por el usuario correspondiente, que se crea al incluir 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 especificó usando el par nombre-valor CustomSentence.

ejemplo

Argumentos de par nombre-valor

expandir todo

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.

En versiones anteriores a R2021a, use 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 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 del par nombre-valor CustomSentence 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 oraciones 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 puede modificar sus valores después de llamar al objeto. Los objetos se bloquean cuando llama a ellos, y la función release los desbloquea.

Si una propiedad es ajustable, puede modificar su valor en cualquier momento.

Para obtener más información sobre cómo modificar los valores de las propiedades, consulte Diseñar sistemas en MATLAB utilizando System objects.

ID de mensajes de nueve sentencias NMEA con soporte integrado, que cumplen con el estándar NMEA 0183, del que 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

[rmcData,ggaData,gsaData,vtgData,gllData,gstData,gsvData,zdaData,hdtData] = pnmea(rawData) analiza datos de nueve oraciones 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 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 nmeaParser System object.

ejemplo

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 más información, 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 más información, 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 más información, 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 más información, 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 más información, 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 más información, 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 más información, 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 más información, 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 más información, 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 usar una función de objeto, especifique el System object como el primer argumento de entrada. Por ejemplo, para liberar recursos de sistema de un System object llamado obj, utilice la siguiente 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 nmeaParser System object ™ 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'];

Cree 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. Por lo tanto, cree el nmeaParser System object 'pnmea' y especifique los ID de mensajes '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 nmeaParser System object 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 nmeaParser System object '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

Leer datos de un registro NMEA de muestra, para que los datos puedan analizarse utilizando nmeaParser System object.

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 oración 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 oración 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, se definen los datos de salida como un arreglo de estructuras 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 oración es válida y convierte los campos de la oración en un arreglo de cadenas. Puedes 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 oración 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 MATLAB, de modo que pueda llamarlo para obtener datos analizados usando el par nombre-valor CustomSentence de nmeaParser System object.

Para descargar otro archivo de función de muestra parserRMB.m que se utiliza en este ejemplo, haga clic en Abrir script en vivo. 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 nmeaParser System object.

    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 analizadora, parserMMCZ, utilizando la función opcional extractNMEASentence, como se muestra a continuación (también puede utilizar otras funciones para extraer los datos no analizados en 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 MATLAB.

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

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

    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