GPS Shield Ublox NEO6M

publicado en: Tutoriales | 0

El GPS Shield Cuantex es una herramienta muy útil que nadie puede perder la oportunidad de aprender a usarla. Para este tutorial, vamos a hacer uso de una biblioteca muy conocida y famosa para este circuito NEO6M que es la TinyGPS. Esta biblioteca es de gran ayuda a la hora de programar un GPS Shield. La biblioteca es libre y se puede descargar de internet en el siguiente enlace:

http://arduiniana.org/libraries/tinygps/

Para este tutorial, solo requerimos la tarjeta GPS Shield Cuantex y un Arduino UNO, aunque cualquier Arduino funciona sin ningún problema.

GPS Shield Ublox NEO6M

gps-cuantex-01

 

La información que se obtendrá del GPS Shield Cuantex será solo la longitud y la latitud. Que como ya sabrán la latitud mide el ángulo entre cualquier punto y el ecuador y la  longitud mide el ángulo a lo largo del Ecuador desde cualquier punto de la Tierra. Se acepta que Greenwich en Londres es la longitud 0 en la mayoría de las sociedades modernas. Las líneas de longitud son círculos máximos que pasan por los polos y se llaman meridianos, las líneas de latitud se denominan paralelos. Una vez instalada la biblioteca TinyGPS vamos a cargar un ejemplo para trabajar con nuestro GPS.

 

Seleccion de prgrama para GPS Shield

Codigo fuente para GPS Shield.

 

#include <SoftwareSerial.h> // se declara la función SoftwareSerial
#include <TinyGPS.h> // se incluye la librería TinyGPS
 
/* 
 Este código de ejemplo muestra el uso normal de un objeto TinyGPS.
 Se requiere el uso de SoftwareSerial, y se supone que tiene una
 4800 baudios dispositivo GPS conectado en serie en los pines 3 (RX) y 4 (TX).
*/
TinyGPS gps;
SoftwareSerial ss(4, 3); // Se declara los pines 4 y 3 como TX y RX
 
static void smartdelay(unsigned long ms);
static void print_float(float val, float invalid, int len, int prec);
static void print_int(unsigned long val, unsigned long invalid, int len);
static void print_date(TinyGPS &gps);
static void print_str(const char *str, int len);
 
void setup()
{ // declaración de datos textuales que veremos en
 Serial.begin(115200); //El monitor serial 
  
 Serial.print("Testing TinyGPS library v. "); Serial.println(TinyGPS::library_version());
 Serial.println("by Mikal Hart");
 Serial.println();
 Serial.println("Sats HDOP Latitude Longitude Chars Sentences Checksum");
 Serial.println(" (deg) (deg) RX RX Fail");
 Serial.println("---------------------------------------------------------");
 
 ss.begin(9600);
}
 
void loop()
{
 float flat, flon;
 unsigned long age, date, time, chars = 0;
 unsigned short sentences = 0, failed = 0;
 static const double LONDON_LAT = 51.508131, LONDON_LON = -0.128002;
  
 print_int(gps.satellites(), TinyGPS::GPS_INVALID_SATELLITES, 5);
 print_int(gps.hdop(), TinyGPS::GPS_INVALID_HDOP, 5);
 gps.f_get_position(&flat, &flon, &age);
 print_float(flat, TinyGPS::GPS_INVALID_F_ANGLE, 10, 6);
 print_float(flon, TinyGPS::GPS_INVALID_F_ANGLE, 11, 6);
 print_int(age, TinyGPS::GPS_INVALID_AGE, 5);
 // print_date(gps);
 // print_float(gps.f_altitude(), TinyGPS::GPS_INVALID_F_ALTITUDE, 7, 2);
 // print_float(gps.f_course(), TinyGPS::GPS_INVALID_F_ANGLE, 7, 2);
 //print_float(gps.f_speed_kmph(), TinyGPS::GPS_INVALID_F_SPEED, 6, 2);
 //print_str(gps.f_course() == TinyGPS::GPS_INVALID_F_ANGLE ? "*** " : TinyGPS::cardinal(gps.f_course()), 6);
 // print_int(flat == TinyGPS::GPS_INVALID_F_ANGLE ? 0xFFFFFFFF : (unsigned long)TinyGPS::distance_between(flat, flon, LONDON_LAT, LONDON_LON) / 1000, 0xFFFFFFFF, 9);
 // print_float(flat == TinyGPS::GPS_INVALID_F_ANGLE ? TinyGPS::GPS_INVALID_F_ANGLE : TinyGPS::course_to(flat, flon, LONDON_LAT, LONDON_LON), TinyGPS::GPS_INVALID_F_ANGLE, 7, 2);
 // print_str(flat == TinyGPS::GPS_INVALID_F_ANGLE ? "*** " : TinyGPS::cardinal(TinyGPS::course_to(flat, flon, LONDON_LAT, LONDON_LON)), 6);
 
 gps.stats(&chars, &sentences, &failed);
 print_int(chars, 0xFFFFFFFF, 6);
 print_int(sentences, 0xFFFFFFFF, 10);
 print_int(failed, 0xFFFFFFFF, 9);
 Serial.println();
  
 smartdelay(1000);
}
 
static void smartdelay(unsigned long ms)
{
 unsigned long start = millis();
 do
 {
 while (ss.available())
 gps.encode(ss.read());
 } while (millis() - start < ms); } static void print_float(float val, float invalid, int len, int prec) { if (val == invalid) { while (len-- > 1)
 Serial.print('*');
 Serial.print(' ');
 }
 else
 {
 Serial.print(val, prec);
 int vi = abs((int)val);
 int flen = prec + (val < 0.0 ? 2 : 1); // . and - flen += vi >= 1000 ? 4 : vi >= 100 ? 3 : vi >= 10 ? 2 : 1;
 for (int i=flen; i<len; ++i)
 Serial.print(' ');
 }
 smartdelay(0);
}
 
static void print_int(unsigned long val, unsigned long invalid, int len)
{
 char sz[32];
 if (val == invalid)
 strcpy(sz, "*******");
 else
 sprintf(sz, "%ld", val);
 sz[len] = 0;
 for (int i=strlen(sz); i<len; ++i) sz[i] = ' '; if (len > 0) 
 sz[len-1] = ' ';
 Serial.print(sz);
 smartdelay(0);
}
 
static void print_date(TinyGPS &gps)
{
 int year;
 byte month, day, hour, minute, second, hundredths;
 unsigned long age;
 gps.crack_datetime(&year, &month, &day, &hour, &minute, &second, &hundredths, &age);
 if (age == TinyGPS::GPS_INVALID_AGE)
 Serial.print("********** ******** ");
 else
 {
 char sz[32];
 sprintf(sz, "%02d/%02d/%02d %02d:%02d:%02d ",
 month, day, year, hour, minute, second);
 Serial.print(sz);
 }
 print_int(age, TinyGPS::GPS_INVALID_AGE, 5);
 smartdelay(0);
}
 
static void print_str(const char *str, int len)
{
 int slen = strlen(str);
 for (int i=0; i<len; ++i)
 Serial.print(i<slen ? str[i] : ' ');
 smartdelay(0);
}

 

Con este código obtendremos los valores deseados del satélite, hay que cargarlo al Arduino una vez ya montado el GPS Shield y la antena, que claro, es indispensable para que funcione nuestra GPS Shield, aunque existen muchos tipos de antenas, se han utilizado dos y cualquiera de las dos se recomienda para utilizar. La antena que viene con la tarjeta es como la primera, en el caso de corroborar que funcione con antenas externas, también se realizaron las pruebas con una como la segunda imagen de las que se muestran a continuación.

 

Antena GPS Shield

Antena para recepcion de datos.

Antena GPS Shield opcional

Antena externa GPS para recepcion de datos.

 

 

GPS Shield

Montaje de la GPS Shield completa.

 

Una vez ya conectado y cargado el programa es hora de abrir el monitor serial, es probable que a la primera no funcione como se desea, hay que ser un poco pacientes ya que unas antenas se tardan un poco más que otras en conectarse al satélite, pero descuiden una vez conectada obtendrán una lectura como la siguiente. Usualmente el tiempo de conexion puede tardar de unos segundos a unos minutos, si tienes problemas para conexión, te recomendamos salir al exterior.

Vista de datos en monitor serial.

Recepcion de datos, monitor serial.

Para terminar y saber si nuestro GPS Shield funciona solo basta con copiar y pegar las coordenadas (latitud y longitud) en aplicación de ubicación preferida, en este ejemplo utilizare Google Maps para que se den una idea de cómo hacerlo:

Ubicación dada por GPS Shield.

Ubicacion MAPS

 

Dejar una opinión