Instrucciones para el módulo GPS NEO-6M con Arduino

¿Quieres aprender a utilizar un módulo GPS con Arduino? ¡Estás en el lugar indicado! En este artículo, te daremos todas las instrucciones que necesitas para utilizar el módulo GPS NEO-6M con tu placa Arduino. ¡Sigue leyendo para convertirte en un experto en la materia!

Esta guía muestra cómo utilizar el módulo GPS NEO-6M con Arduino para obtener datos GPS. GPS significa Sistema de Posicionamiento Global y se puede utilizar para determinar la posición, el tiempo y la velocidad mientras se viaja.

Aprenderás lo siguiente:

• Conecte el módulo GPS NEO-6M al Arduino UNO
• Obtener datos GPS sin procesar
• Analice datos sin procesar para obtener información GPS seleccionada y legible.
• Obtener ubicación

Presentamos el módulo GPS NEO-6M

El módulo GPS NEO-6M se muestra en la siguiente figura. Viene con una antena externa pero no tiene pines. Entonces tienes que conseguir algunos y soldarlos.

• Este módulo tiene una antena externa y EEPROM integrada.
• Interfaz: RS232 TTL
• Fuente de alimentación: 3V a 5V
• Velocidad de baudios estándar: 9600 bps
• Funciona con sentencias NMEA estándar

El módulo GPS NEO-6M también es compatible con otras placas de microcontrolador. Puede encontrar información sobre el uso del módulo GPS NEO-6M con Raspberry Pi aquí: Sistema de alerta por correo electrónico al cambiar de ubicación con Raspberry Pi y módulo GPS.

¿Donde comprar?

Puedes conseguir el módulo GPS NEO-6M por un precio de entre 5 y 20 dólares. Recomendamos que Página del módulo GPS NEO-6M en Maker Advisor para comparar precios en diferentes tiendas y encontrar la mejor.

Asignación de pines

El módulo GPS NEO-6M tiene cuatro pines: VCC, RX, TexasY Dimensiones. El módulo se comunica con el Arduino a través del puerto serie mediante los pines TX y RX, por lo que el cableado no puede ser más sencillo:

Módulo GPS NEO-6M	Cableado con Arduino UNO
VCC	5V
RX	Pin TX en la serie del software
Texas	Pin RX en la serie del software
Dimensiones	Dimensiones

Recuperar datos GPS sin procesar

Para obtener datos GPS sin procesar, solo necesita iniciar la comunicación en serie con el módulo GPS a través del software Serial. Continúe leyendo para aprender cómo hacer esto.

Piezas requeridas

Para probar este ejemplo necesitará las siguientes piezas:

• arduino – leer Los mejores kits de inicio de Arduino
• Módulo GPS NEO-6M
• Cables de puente

Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!

Esquema

Conecte el módulo GPS NEO-6M a su Arduino siguiendo el diagrama a continuación.

• El pin GND del módulo está conectado a Arduino Dimensiones Bolígrafo
• El pin RX del módulo está conectado a Arduino Pluma 3
• El pin TX del módulo está conectado a Arduino Pluma 4
• El pin VCC del módulo está conectado a Arduino 5V Bolígrafo

código

Copie el siguiente código en su IDE de Arduino y cárguelo en su placa Arduino.

/*
 * Rui Santos 
 * Complete Project Details https://randomnerdtutorials.com
 */
 
#include <SoftwareSerial.h>

// The serial connection to the GPS module
SoftwareSerial ss(4, 3);

void setup(){
  Serial.begin(9600);
  ss.begin(9600);
}

void loop(){
  while (ss.available() > 0){
    // get the byte data from the GPS
    byte gpsData = ss.read();
    Serial.write(gpsData);
  }
}

Ver código sin formato

Este boceto supone que usted Pluma 4 Y Pluma 3 como pines seriales RX y TX para establecer comunicación serial con el módulo GPS. Si usa otros pines, debe editar esto en la siguiente línea:

SoftwareSerial ss(4, 3);

Además, si su módulo utiliza una velocidad en baudios predeterminada distinta de 9600 bps, debe cambiar el código en la siguiente línea:

ss.begin(9600);

Este boceto monitorea el puerto serie GPS y cuando se reciben datos del módulo se envían al monitor serie.

while (ss.available() > 0){
  // get the byte data from the GPS
  byte gpsData = ss.read();
  Serial.write(gpsData);
}

Abra el monitor serie con una velocidad de 9600 baudios.

Debería recibir una variedad de información en el idioma estándar del GPS NMEA. Cada línea que aparece en el monitor serie es una sentencia NMEA.

NMEA significa Asociación Nacional de Electrónica Marina y es un formato de datos estándar en el mundo del GPS respaldado por los fabricantes de GPS.

Comprensión de frases NMEA

Las sentencias NMEA comienzan con el carácter $ y cada campo de datos está separado por una coma.

$GPGGA,110617.00,41XX.XXXXX,N,00831.54761,W,1,05,2.68,129.0,M,50.1,M,,*42
$GPGSA,A,3,06,09,30,07,23,,,,,,,,4.43,2.68,3.53*02
$GPGSV,3,1,11,02,48,298,24,03,05,101,24,05,17,292,20,06,71,227,30*7C
$GPGSV,3,2,11,07,47,138,33,09,64,044,28,17,01,199,,19,13,214,*7C
$GPGSV,3,3,11,23,29,054,29,29,01,335,,30,29,167,33*4E
$GPGLL,41XX.XXXXX,N,00831.54761,W,110617.00,A,A*70
$GPRMC,110618.00,A,41XX.XXXXX,N,00831.54753,W,0.078,,030118,,,A*6A 
$GPVTG,,T,,M,0.043,N,0.080,K,A*2C

Hay diferentes tipos de sentencias NMEA. El tipo de mensaje lo especifican los caracteres antes de la primera coma.

El GP después de $ indica que es una ubicación GPS. El $GPGGA es el mensaje GPS NMEA básico que proporciona ubicación en 3D y datos de precisión. En la siguiente frase:

$GPGGA,110617.00,41XX.XXXXX,N,00831.54761,W,1,05,2.68,129.0,M,50.1,M,,*42

• 110617 – representa la hora en que se realizó la determinación de la ubicación, 11:06:17 UTC
• 41XX.XXXXXX,N – Latitud 41 grados XX.XXXXX' N
• 00831.54761,W – Longitud 008 grados 31.54761′ W
• 1 – Calidad de fijación (0 = no válida; 1 = corrección GPS; 2 = corrección DGPS; 3 = corrección PPS; 4 = cinemática en tiempo real; 5 = RTK flotante; 6 = estimado (estimación); 7 = modo de entrada manual; 8 = modo de simulación)
• 05 – Número de satélites rastreados
• 2,68 – Dilución horizontal de la posición
• 129,0, M – Altura en metros sobre el nivel del mar
• 50,1, M – Altura del geoide (nivel medio del mar) sobre el elipsoide WGS84
• campo vacío: tiempo en segundos desde la última actualización de DGPS
• campo vacío: número de identificación de la estación DGPS
• *42 – los datos de la suma de comprobación siempre comienzan con *

Las otras sentencias NMEA proporcionan información adicional:

• $GPGSA – GPS DOP y satélites activos
• $GPGSV – Información detallada del satélite GPS.
• $GPGLL – Latitud y longitud geográficas
• $GPRMC – Datos GPS importantes (posición, velocidad, hora)
• $GPVTG – Velocidad bien hecha

Para saber qué significa cada campo de datos en cada una de estas oraciones, puede leer Datos NMEA aquí.

Análisis de sentencias NMEA con la biblioteca TinyGPS++

Puede trabajar con los datos sin procesar del GPS o convertir estos mensajes NMEA a un formato legible y útil almacenando las cadenas en variables. Para ello utilizamos el Biblioteca TinyGPS++.

Esta biblioteca facilita la recuperación de información de ubicación en un formato útil y fácil de entender. Puedes hacer clic en Aquí para obtener más información sobre la biblioteca TinyGPS++.

Instalación de la biblioteca TinyGPS++

Siga los siguientes pasos para instalar la biblioteca TinyGPS++ en su IDE de Arduino:

1. Hacer clic Aquí para descargar la biblioteca TinyGPSPlus. Deberías tener una carpeta .zip en tu carpeta de Descargas.
2. Extraiga la carpeta .zip y debería obtener la carpeta maestra de TinyGPSPlus.
3. Cambie el nombre de su carpeta de TinyGPSPlus Maestro a TinyGPSPlus
4. Mueva la carpeta TinyGPSPlus a la carpeta de la biblioteca de instalación de su Arduino IDE
5. Finalmente, vuelva a abrir su IDE de Arduino

La biblioteca proporciona varios ejemplos de uso. En tu IDE de Arduino solo necesitas archivo > Ejemplos > PequeñoGPS++y elija entre los ejemplos proporcionados.

nota: Los ejemplos proporcionados en la biblioteca asumen una velocidad de 4800 baudios para el módulo GPS. Debe cambiar esto a 9600 si está utilizando el módulo GPS NEO-6M.

Determinación de ubicación con el módulo GPS NEO-6M y la biblioteca TinyGPS++

Usando la biblioteca TinyGPS++ puedes obtener la ubicación en un formato conveniente y útil. A continuación proporcionamos un código para obtener la ubicación desde el GPS. Esta es una versión simplificada de uno de los ejemplos de la biblioteca.

/*
 * Rui Santos 
 * Complete Project Details https://randomnerdtutorials.com
 */
 
#include <TinyGPS++.h>
#include <SoftwareSerial.h>

static const int RXPin = 4, TXPin = 3;
static const uint32_t GPSBaud = 9600;

// The TinyGPS++ object
TinyGPSPlus gps;

// The serial connection to the GPS device
SoftwareSerial ss(RXPin, TXPin);

void setup(){
  Serial.begin(9600);
  ss.begin(GPSBaud);
}

void loop(){
  // This sketch displays information every time a new sentence is correctly encoded.
  while (ss.available() > 0){
    gps.encode(ss.read());
    if (gps.location.isUpdated()){
      Serial.print("Latitude= "); 
      Serial.print(gps.location.lat(), 6);
      Serial.print(" Longitude= "); 
      Serial.println(gps.location.lng(), 6);
    }
  }
}

Ver código sin formato

Empiece por importar las bibliotecas que necesita: TinyGPSPlus Y SoftwareSerial

#include <TinyGPS++.h>
#include <SoftwareSerial.h>

Luego defina los pines seriales RX y TX del software, así como la velocidad en baudios del GPS. Si utiliza otros pines para el software serie, deberá cambiarlos aquí. Si su módulo GPS utiliza una velocidad de baudios estándar diferente, también debe cambiarla.

static const int RXPin = 4, TXPin = 3;
static const uint32_t GPSBaud = 9600;

Luego crea uno PequeñoGPS++ Objeto:

TinyGPSPlus gps;

E inicie una conexión en serie en los pines que definió anteriormente

SoftwareSerial ss(RXPin, TXPin);

En el configuración()Inicializar la comunicación serie, tanto para mostrar las lecturas en el monitor serie como para comunicarse con el módulo GPS.

void setup() {
  Serial.begin(9600);
  ss.begin(GPSBaud);
}

El bucle es donde solicitas la información. Para que TinyGPS++ funcione, debes enrutar repetidamente los personajes allí desde el módulo GPS usando el codificar() Método.

while (ss.available() > 0){
 gps.encode(ss.read());

Entonces tú puedes GPS Objeto para ver si los campos de datos se han actualizado:

if (gps.location.isUpdated()){
  Serial.print("Latitude="); Serial.print(gps.location.lat(), 6);
  Serial.print("Longitude="); Serial.println(gps.location.lng(), 6);
}

Determinar la latitud y la longitud es muy fácil: gps.ubicación.lat()Y gps.ubicación.lng()respectivamente.

Sube el código a tu Arduino. Ahora debería ver la posición en el monitor serie. Después de cargar el código, espere unos minutos mientras el módulo ajusta la posición para obtener datos más precisos.

Obtenga más información de GPS utilizando la biblioteca TinyGPS++

La biblioteca TinyGPS++ facilita la obtención de mucha más información que solo la ubicación. Además de la ubicación, puedes obtener:

• Fecha
• Tiempo
• velocidad
• curso
• Altura
• Satélites
• hdop

El siguiente código ilustra cómo puede obtener fácilmente toda esta información.

/*
 * Rui Santos 
 * Complete Project Details https://randomnerdtutorials.com
 *
 * Based on the example TinyGPS++ from arduiniana.org
 *
 */
 
#include <TinyGPS++.h>
#include <SoftwareSerial.h>

static const int RXPin = 4, TXPin = 3;
static const uint32_t GPSBaud = 9600;

// The TinyGPS++ object
TinyGPSPlus gps;

// The serial connection to the GPS device
SoftwareSerial ss(RXPin, TXPin);

void setup(){
  Serial.begin(9600);
  ss.begin(GPSBaud);
}

void loop(){
  // This sketch displays information every time a new sentence is correctly encoded.
  while (ss.available() > 0){
    gps.encode(ss.read());
    if (gps.location.isUpdated()){
      // Latitude in degrees (double)
      Serial.print("Latitude= "); 
      Serial.print(gps.location.lat(), 6);      
      // Longitude in degrees (double)
      Serial.print(" Longitude= "); 
      Serial.println(gps.location.lng(), 6); 
       
      // Raw latitude in whole degrees
      Serial.print("Raw latitude = "); 
      Serial.print(gps.location.rawLat().negative ? "-" : "+");
      Serial.println(gps.location.rawLat().deg); 
      // ... and billionths (u16/u32)
      Serial.println(gps.location.rawLat().billionths);
      
      // Raw longitude in whole degrees
      Serial.print("Raw longitude = "); 
      Serial.print(gps.location.rawLng().negative ? "-" : "+");
      Serial.println(gps.location.rawLng().deg); 
      // ... and billionths (u16/u32)
      Serial.println(gps.location.rawLng().billionths);

      // Raw date in DDMMYY format (u32)
      Serial.print("Raw date DDMMYY = ");
      Serial.println(gps.date.value()); 

      // Year (2000+) (u16)
      Serial.print("Year = "); 
      Serial.println(gps.date.year()); 
      // Month (1-12) (u8)
      Serial.print("Month = "); 
      Serial.println(gps.date.month()); 
      // Day (1-31) (u8)
      Serial.print("Day = "); 
      Serial.println(gps.date.day()); 

      // Raw time in HHMMSSCC format (u32)
      Serial.print("Raw time in HHMMSSCC = "); 
      Serial.println(gps.time.value()); 

      // Hour (0-23) (u8)
      Serial.print("Hour = "); 
      Serial.println(gps.time.hour()); 
      // Minute (0-59) (u8)
      Serial.print("Minute = "); 
      Serial.println(gps.time.minute()); 
      // Second (0-59) (u8)
      Serial.print("Second = "); 
      Serial.println(gps.time.second()); 
      // 100ths of a second (0-99) (u8)
      Serial.print("Centisecond = "); 
      Serial.println(gps.time.centisecond()); 

      // Raw speed in 100ths of a knot (i32)
      Serial.print("Raw speed in 100ths/knot = ");
      Serial.println(gps.speed.value()); 
      // Speed in knots (double)
      Serial.print("Speed in knots/h = ");
      Serial.println(gps.speed.knots()); 
      // Speed in miles per hour (double)
      Serial.print("Speed in miles/h = ");
      Serial.println(gps.speed.mph()); 
      // Speed in meters per second (double)
      Serial.print("Speed in m/s = ");
      Serial.println(gps.speed.mps()); 
      // Speed in kilometers per hour (double)
      Serial.print("Speed in km/h = "); 
      Serial.println(gps.speed.kmph()); 

      // Raw course in 100ths of a degree (i32)
      Serial.print("Raw course in degrees = "); 
      Serial.println(gps.course.value()); 
      // Course in degrees (double)
      Serial.print("Course in degrees = "); 
      Serial.println(gps.course.deg()); 

      // Raw altitude in centimeters (i32)
      Serial.print("Raw altitude in centimeters = "); 
      Serial.println(gps.altitude.value()); 
      // Altitude in meters (double)
      Serial.print("Altitude in meters = "); 
      Serial.println(gps.altitude.meters()); 
      // Altitude in miles (double)
      Serial.print("Altitude in miles = "); 
      Serial.println(gps.altitude.miles()); 
      // Altitude in kilometers (double)
      Serial.print("Altitude in kilometers = "); 
      Serial.println(gps.altitude.kilometers()); 
      // Altitude in feet (double)
      Serial.print("Altitude in feet = "); 
      Serial.println(gps.altitude.feet()); 

      // Number of satellites in use (u32)
      Serial.print("Number os satellites in use = "); 
      Serial.println(gps.satellites.value()); 

      // Horizontal Dim. of Precision (100ths-i32)
      Serial.print("HDOP = "); 
      Serial.println(gps.hdop.value()); 
    }
  }
}

Ver código sin formato

El pequeño GPS++ biblioteca El uso de todas las funciones se explica detalladamente.

Envolver

Esperamos que esta guía le haya resultado útil. Tenemos la intención de utilizar un registrador de datos GPS con el Módulo GPS NEO-6M y eso módulo de tarjeta SDAsí que estad atentos.

Si te gustó este proyecto, también te puede gustar:

• Instrucciones para el Escudo GPRS GSM SIM900 con Arduino
• Sistema de alerta por correo electrónico cuando cambia de ubicación con Raspberry Pi y módulo GPS
• Proyectos Arduino paso a paso.

Gracias por leer.

Instrucciones para el módulo GPS NEO-6M con Arduino

Esta guía muestra cómo utilizar el módulo GPS NEO-6M con Arduino para obtener datos de GPS. El GPS, que significa Sistema de Posicionamiento Global, se puede utilizar para determinar la posición, el tiempo y la velocidad si estás viajando.

Aprenderás cómo:

1. Cablear el módulo GPS NEO-6M al Arduino UNO
2. Obtener datos de GPS en bruto
3. Analizar los datos en bruto para obtener información de GPS seleccionada y legible
4. Obtener la ubicación

El módulo GPS NEO-6M cuenta con una antena externa y no incluye pines de cabecera, por lo que necesitarás conseguir y soldar algunos.

Este módulo tiene una antena externa y una EEPROM incorporada. Interfaz: RS232 TTL. Alimentación: 3V a 5V. Baudrate predeterminado: 9600 bps. Funciona con sentencias NMEA estándar.

El módulo GPS NEO-6M también es compatible con otras placas de microcontroladores. Para aprender cómo usar el módulo GPS NEO-6M con el Raspberry Pi, puedes leer: Sistema de Alerta por Correo Electrónico en Cambio de Ubicación con Raspberry Pi y Módulo GPS

¿Dónde comprar?

Puedes conseguir el módulo GPS NEO-6M por un precio entre $5 y $20. Recomendamos revisar la página del módulo GPS NEO-6M en Maker Advisor para comparar precios en diferentes tiendas y encontrar el mejor.

Cableado de pines

El módulo GPS NEO-6M tiene cuatro pines: VCC, RX, TX y GND. El módulo se comunica con el Arduino a través de comunicación serial usando los pines TX y RX, por lo que el cableado no podría ser más sencillo:

• NEO-6M GPS Module a Arduino UNO:
• VCC – 5V
• RX – Pin TX definido en software serial
• TX – Pin RX definido en software serial
• GND – GND

Continúa leyendo en Random Nerd Tutorials para obtener más información detallada sobre cómo utilizar el módulo GPS NEO-6M con Arduino.